elanous 0.2.14 → 0.2.16

package/src/knowledge/know-find.ts

@@ -0,0 +1,105 @@
+import { createRequire } from 'node:module';
+import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
+import { debug } from '../debug/log.js';
+
+/** Directive row fields this search reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only, so public builds bundle cleanly and report the directive source as unreadable. */
+function openDirectiveIndex(): { search(q: string): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new () => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex();
+}
+
+export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson';
+export interface KnowHit {
+  source: KnowSource;
+  id: string;
+  title: string;
+  status: string;
+  at: string;
+  current: boolean;
+  ref: string;
+}
+export interface KnowResult {
+  rows: KnowHit[];
+  unavailable: Array<{ source: KnowSource; reason: string }>;
+}
+export interface KnowFindDeps {
+  directives: (query: string) => DirectiveRow[];
+  decisions: () => DecisionEntry[];
+  checklist: (version: string) => Checklist;
+  lessons: (query: string) => LessonRow[];
+  versions: () => string[];
+  now: () => Date;
+}
+
+function versions(): string[] {
+  const current = devVersion().replace(/-dev\.\d+$/, '');
+  const parts = current.split('.').map(Number);
+  return [current, `${parts[0]}.${parts[1]}.${parts[2]! + 1}`];
+}
+
+const defaults: KnowFindDeps = {
+  directives: (query) => {
+    const index = openDirectiveIndex();
+    try { return index.search(query); } finally { index.close(); }
+  },
+  decisions: () => new DecisionLedger().list({ status: 'all' }),
+  checklist: (version) => listChecklist(version),
+  lessons: (query) => new LessonLedger().find(query),
+  versions,
+  now: () => new Date(),
+};
+
+function matches(text: string, words: string[]): boolean {
+  const normalized = text.toLocaleLowerCase();
+  return words.every((word) => normalized.includes(word));
+}
+
+export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowResult {
+  const read = { ...defaults, ...deps };
+  const words = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  if (!words.length) throw new Error('know: 질문이 필요합니다');
+  const rows: KnowHit[] = [];
+  const unavailable: KnowResult['unavailable'] = [];
+  const attempt = (source: KnowSource, work: () => void): void => {
+    try { work(); }
+    catch (error) { unavailable.push({ source, reason: error instanceof Error ? error.message : String(error) }); }
+  };
+  const cutoff = read.now().getTime() - 30 * 86400000;
+  attempt('directive', () => {
+    for (const row of read.directives(query)) rows.push({ source: 'directive', id: `${row.source_file}:${row.line_no}`,
+      title: row.text.replace(/\s+/g, ' ').slice(0, 160), status: 'recorded', at: row.ts,
+      current: Number.isFinite(Date.parse(row.ts)) && Date.parse(row.ts) >= cutoff, ref: `${row.source_file}:${row.line_no}` });
+  });
+  attempt('decision', () => {
+    for (const row of read.decisions()) {
+      if (!matches([row.title, row.scqa.s, row.scqa.c, row.scqa.q, row.scqa.a].filter(Boolean).join(' '), words)) continue;
+      rows.push({ source: 'decision', id: row.id, title: row.title, status: row.status,
+        at: row.decidedAt ?? row.withdrawnAt ?? row.raisedAt ?? row.importedAt ?? '', current: row.status === 'open',
+        ref: row.refs?.[0] ?? `decisions show ${row.id}` });
+    }
+  });
+  attempt('checklist', () => {
+    for (const version of new Set(read.versions())) {
+      for (const row of read.checklist(version).items) {
+        if (!matches(`${row.id} ${row.title}`, words)) continue;
+        rows.push({ source: 'checklist', id: row.id, title: row.title, status: row.status,
+          at: row.updatedAt, current: row.status === 'yellow', ref: `release checklist status --version ${version}` });
+      }
+    }
+  });
+  attempt('lesson', () => {
+    for (const row of read.lessons(query)) rows.push({ source: 'lesson', id: row.id, title: row.incident,
+      status: row.status, at: row.updated_at, current: row.occurrence_count > 1, ref: `lesson show ${row.id}` });
+  });
+  rows.sort((a, b) => Number(b.current) - Number(a.current) || (Date.parse(b.at) || 0) - (Date.parse(a.at) || 0)
+    || a.source.localeCompare(b.source) || a.id.localeCompare(b.id));
+  debug.log('knowledge.know', 'query', { query, counts: Object.fromEntries((['directive', 'decision', 'checklist', 'lesson'] as const)
+    .map(source => [source, rows.filter(row => row.source === source).length])), unavailable });
+  return { rows, unavailable };
+}

package/src/llm.ts

@@ -36,7 +36,7 @@ import {
   type ProviderFallbackAttempt,
   type ProviderFallbackTerminalVerdict,
 } from './session-runtime/retry-policy.js';
-import { fetchApiWithRetry } from './session-runtime/retry-api.js';
+import { fetchApiWithRetry, OverloadFailoverError, type FetchApiWithRetryOpts } from './session-runtime/retry-api.js';
 import { resolveModelAlias } from './intelligence-map/model-alias.js';
 import { reasoningEffortCeiling as reasoningEffortCeilingOf } from './intelligence-map/model-catalog.js';
 import { inferProviderFromModel as registryInferProviderFromModel } from './registry/normalize.js';
@@ -407,6 +407,10 @@ export interface LLMOpts {
       background?: 'transparent' | 'opaque' | 'auto';
     };
   };
+  /** Unused configured fallbacks. The HTTP retry layer switches provider
+   *  after k consecutive overload responses before spending those retries.
+   *  Callers that already pinned a provider omit this (0). */
+  remainingFallbacks?: number;
 }
 
 export interface LLMProvider {
@@ -1310,6 +1314,20 @@ export async function* parseOpenAISSELines(
  *  the request URL. The OpenAI streamer is shared by openai/grok/local
  *  endpoints — all three pass through here. The string lands in the
  *  `llm.retry` debug snapshot and the `ApiHttpError.provider` field. */
+/** Retries still left for this HTTP call. Callers that already know a
+ *  fallback remains pass it so overload switches before those retries. */
+function retryOptsFor(
+  provider: string,
+  errorPrefix: string,
+  remainingFallbacks?: number,
+): FetchApiWithRetryOpts {
+  return {
+    provider,
+    errorPrefix,
+    ...(remainingFallbacks !== undefined && remainingFallbacks > 0 ? { remainingFallbacks } : {}),
+  };
+}
+
 function inferOpenAIProviderName(url: string): string {
   if (url.includes('x.ai')) return 'grok';
   if (url.includes('openai.com')) return 'openai';
@@ -1326,6 +1344,7 @@ async function* streamOpenAIEvents(
    *  `x-grok-client-version` 이 빠지면 HTTP 426 으로 거절된다(실측).
    *  ⛔ 생략하면 종전과 «바이트 동일** — 기존 호출자 무회귀. */
   extraHeaders?: Record<string, string>,
+  remainingFallbacks?: number,
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   const headers: Record<string, string> = { 'Content-Type': 'application/json', ...(extraHeaders ?? {}) };
   if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
@@ -1353,10 +1372,7 @@ async function* streamOpenAIEvents(
       body: JSON.stringify({ ...body, stream: true }),
       signal,
     },
-    {
-      provider: inferOpenAIProviderName(url),
-      errorPrefix: 'LLM API',
-    },
+    retryOptsFor(inferOpenAIProviderName(url), 'LLM API', remainingFallbacks),
   );
 
   debug.log('llm.response.status', `${response.status} ${response.statusText || ''}`.trim(), {
@@ -2030,6 +2046,8 @@ export async function* streamCodexResponsesEvents(
      *  call. Best-effort; null/undefined if the backend skips the
      *  event. */
     onResponseCreated?: (id: string) => void;
+    /** Unused configured fallbacks. Overload k times switches before retries. */
+    remainingFallbacks?: number;
   } = {},
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   const startedAt = Date.now();
@@ -2118,10 +2136,7 @@ export async function* streamCodexResponsesEvents(
       }),
       signal,
     },
-    {
-      provider: 'codex',
-      errorPrefix: 'Codex API',
-    },
+    retryOptsFor('codex', 'Codex API', extra.remainingFallbacks),
   );
   debug.log('llm.response.status', `codex ${response.status}`, {
     url, status: response.status, elapsedMs: Date.now() - startedAt,
@@ -3103,6 +3118,7 @@ async function* streamAnthropicEvents(
   apiKey: string,
   body: any,
   signal?: AbortSignal,
+  remainingFallbacks?: number,
 ): AsyncGenerator<LLMStreamEvent, void, unknown> {
   // Wave 6 (2026-05-04) — Anthropic beta headers from
   // ref/opencode `provider/provider.ts:181-185` analysis.
@@ -3139,10 +3155,7 @@ async function* streamAnthropicEvents(
       body: JSON.stringify({ ...body, stream: true }),
       signal,
     },
-    {
-      provider: 'anthropic',
-      errorPrefix: 'Anthropic API',
-    },
+    retryOptsFor('anthropic', 'Anthropic API', remainingFallbacks),
   );
 
   try {
@@ -4507,7 +4520,11 @@ export async function streamLLM(
     const consumed = await consumeProviderText(
       activeProvider,
       messages,
-      { ...opts, model: activeModel },
+      {
+        ...opts,
+        model: activeModel,
+        remainingFallbacks: opts.provider ? 0 : remainingFallbackProviderNames(attemptedProviders, opts).length,
+      },
       onChunk,
     );
     const full = consumed.full;
@@ -4528,6 +4545,22 @@ export async function streamLLM(
     }
 
     const err: any = consumed.error;
+    if (err instanceof OverloadFailoverError && !opts.provider) {
+      const switched = providerByName('grok');
+      if (switched && !attemptedProviders.has(switched.name) && switched.available() && full.length === 0) {
+        debug.log('llm.router', 'overload-failover', {
+          blockedProvider: activeProvider.name,
+          fallbackProvider: switched.name,
+          streak: err.streak,
+          status: err.status,
+          kind: err.kind,
+        }, { level: 'warn' });
+        activeProvider = switched;
+        modelOverride = undefined;
+        attemptedProviders.add(activeProvider.name);
+        continue;
+      }
+    }
     const reason = sanitizeProviderFailureReason(err?.message || String(err));
     debug.log('llm.router.error', 'streamLLM', {
       provider: activeProvider.name,
@@ -8350,9 +8383,11 @@ export async function streamLLMWithTools(
     // `tools: activeTools` (not opts.tools) so mid-loop hydration reaches the
     // provider on the next turn. turn-0 keeps opts.toolChoice; later turns
     // revert to auto (see above).
-    const buildTurnOpts = () => turn === 0
-      ? { ...opts, model: activeModel, tools: activeTools }
-      : { ...opts, model: activeModel, tools: activeTools, toolChoice: undefined };
+    const buildTurnOpts = () => {
+      const remainingFallbacks = opts.provider ? 0 : remainingFallbackProviderNames(attemptedProviders, opts).length;
+      const base = { ...opts, model: activeModel, tools: activeTools, remainingFallbacks };
+      return turn === 0 ? base : { ...base, toolChoice: undefined };
+    };
     let turnOpts = buildTurnOpts();
     // reasoning-heavy family(codex/claude/gemini/grok/local)는 침묵 추론 구간이 길어 idle watchdog 를
     // family-aware 로 상향(2026-07-19 goal-exec → 아크4 전-family). fast/mini(gpt·other)만 45s 유지.
@@ -8390,6 +8425,26 @@ export async function streamLLMWithTools(
         ]);
       } catch (err) {
         if (idleTimer) clearTimeout(idleTimer);
+        if (err instanceof OverloadFailoverError && !opts.provider) {
+          const switched = providerByName('grok');
+          if (switched && !attemptedProviders.has(switched.name) && switched.available() && evCount === 0) {
+            debug.log('llm.router', 'overload-failover', {
+              turn,
+              blockedProvider: activeProvider.name,
+              fallbackProvider: switched.name,
+              streak: err.streak,
+              status: err.status,
+              kind: err.kind,
+            }, { level: 'warn' });
+            const finalized = finalizeStreamingProviderModel(switched, switched.defaultModel);
+            activeProvider = finalized.provider;
+            activeModel = finalized.model;
+            attemptedProviders.add(activeProvider.name);
+            turnOpts = buildTurnOpts();
+            streamIter = undefined;
+            continue;
+          }
+        }
         // 명시 provider 선택만 폴백 대상이 아니다 — `streamLLM` 과 같은 계약으로
         // «원본 오류»를 그대로 올린다. 모델만 전달된 호출은 다음 provider의 기본 모델로 재시도한다.
         if (opts.provider) throw err;
@@ -10958,6 +11013,7 @@ function makeCodexProvider(cfg: UCLLMConfig): LLMProvider {
           // lastResponseId stays undefined and we fall back to full
           // input on the next turn (safe — just no token savings).
           onResponseCreated: useStore ? (id) => { lastResponseId = id; } : undefined,
+          remainingFallbacks: opts.remainingFallbacks,
         });
         // Snapshot full input AFTER the stream completes so the next
         // call's delta computation uses what the backend actually has
@@ -10991,7 +11047,7 @@ function makeCodexProvider(cfg: UCLLMConfig): LLMProvider {
         ...openAiTemperatureField(apiKeyModel, opts.temperature ?? 0.3),
         ...openAiOutputTokenField(apiKeyModel, opts.maxTokens ?? 2048),
         ...(tools ? { tools } : {}),
-      }, opts.signal);
+      }, opts.signal, undefined, opts.remainingFallbacks);
     },
     async *chat(messages, opts = {}) { yield* textOnly(this.streamChat!(messages, opts)); },
   };
@@ -11085,7 +11141,7 @@ function makeAnthropicProvider(cfg: UCLLMConfig): LLMProvider {
         ...(effort ? { thinking: { type: 'adaptive' }, output_config: { effort } } : {}),
         ...anthropicTemperatureField(anthropicModel, thinkingActive, opts.temperature),
         ...(tools ? { tools } : {}),
-      }, opts.signal);
+      }, opts.signal, opts.remainingFallbacks);
     },
     async *chat(messages, opts = {}) { yield* textOnly(this.streamChat!(messages, opts)); },
   };

package/src/loops/budget.ts

@@ -8,6 +8,8 @@ export interface SpawnBudgetInput {
   caps?: Partial<Record<OrchestratorSeat, number>>;
   /** Release-gate seat limits. Missing seats use the gate default of four. */
   gate?: Partial<Record<OrchestratorSeat, number>>;
+  /** Optional queue-injected cap; it may lower, never replace, the configured limit. */
+  injectedCap?: number;
 }
 
 export interface SpawnBudgetDecision {
@@ -16,13 +18,42 @@ export interface SpawnBudgetDecision {
   cap: number;
 }
 
-/** A release gate can lower, but never raise, the configured per-seat cap. */
-export function decideSpawn({ seat, running, caps, gate }: SpawnBudgetInput): SpawnBudgetDecision {
+export type SeatCapDetails = {
+  cap: number;
+  seatCaps: number | '?';
+  releaseGate: number | '?';
+  injectedCap?: number | '?';
+  winners: ('releaseGate' | 'seatCaps' | 'injectedCap')[];
+};
+
+/** Keep the cap calculation and the names shown to operators on the same source of truth. */
+export function seatCapDetails({ seat, caps, gate, injectedCap }: Pick<SpawnBudgetInput, 'seat' | 'caps' | 'gate' | 'injectedCap'>): SeatCapDetails {
   const configured = caps?.[seat] ?? ORCHESTRATOR_DEFAULTS.seatCaps[seat];
   const gated = gate?.[seat] ?? 4;
-  const cap = Number.isSafeInteger(configured) && configured >= 0 && Number.isSafeInteger(gated) && gated >= 0
-    ? Math.min(configured, gated)
-    : 0;
+  const valid = (value: number): boolean => Number.isSafeInteger(value) && value >= 0;
+  const seatCaps = valid(configured) ? configured : '?';
+  const releaseGate = valid(gated) ? gated : '?';
+  const injected = injectedCap === undefined ? undefined : valid(injectedCap) ? injectedCap : '?';
+  const cap = [seatCaps, releaseGate, injected].some((value) => value === '?') ? 0
+    : Math.min(seatCaps as number, releaseGate as number, injected === undefined ? Infinity : injected as number);
+  const winners: SeatCapDetails['winners'] = [];
+  if (seatCaps !== '?' && releaseGate !== '?' && injected !== '?') {
+    if (releaseGate === cap) winners.push('releaseGate');
+    if (seatCaps === cap) winners.push('seatCaps');
+    if (injected === cap) winners.push('injectedCap');
+  }
+  return { cap, seatCaps, releaseGate, ...(injected === undefined ? {} : { injectedCap: injected }), winners };
+}
+
+export function seatCapReason(seat: OrchestratorSeat, active: number, details: SeatCapDetails): string {
+  const keys = (['releaseGate', 'seatCaps', 'injectedCap'] as const).filter((name) => name !== 'injectedCap' || details.injectedCap !== undefined);
+  const candidates = [...details.winners, ...keys.filter((name) => !details.winners.includes(name))];
+  return `seat ${seat}: ${active}/${details.cap} (${candidates.map((name) => `${name}.${seat}=${details[name]}`).join(' · ')})`;
+}
+
+/** A release gate or injected queue cap can lower, but never raise, the configured per-seat cap. */
+export function decideSpawn({ seat, running, caps, gate, injectedCap }: SpawnBudgetInput): SpawnBudgetDecision {
+  const { cap } = seatCapDetails({ seat, caps, gate, injectedCap });
   if (!Number.isSafeInteger(running) || running === null || running === undefined || running < 0) {
     return { allow: false, reason: 'unknown-running', cap };
   }

package/src/loops/checker.ts

@@ -14,8 +14,8 @@ export type LoopScope = 'graph-only' | 'registry';
 export interface CheckEntry {
   id: string;
   owner?: string;
-  ownerSource?: 'header' | 'config' | 'seat' | 'default';
-  evidence?: 'log-mtime';
+  ownerSource?: 'header' | 'config' | 'seat' | 'seat-arg' | 'default';
+  evidence?: 'log-mtime' | 'registry';
   mode?: string;
   expectEveryMinutes?: number;
   /** The scheduled fire before the latest one (cron loops). A run older than this missed two scheduled fires. */

package/src/loops/orchestrator/author-depth.ts

@@ -1,5 +1,7 @@
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { debug } from '../../debug/log.js';
 import { defaultListHarnessProcesses } from '../../harness/harness-cli-command.js';
 import { listHarnessQueue, type QueueItem } from '../../harness/harness-queue.js';
@@ -7,15 +9,19 @@ import { releaseLedgerRoot } from '../../instance/resolve.js';
 import { listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
 import { listSchedules } from '../../release-loop/release-schedule.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../../user-config.js';
+import { checkAuthorInput } from './author-input-check.js';
+import { AuthorLedger } from './author-ledger.js';
 import { collectWork, findOverlaps, type WorkItem } from './overlap.js';
 import { seatOfTree, trafficTick, TRAFFIC_SEATS } from './traffic.js';
 
-export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'> & { version: string };
+export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status' | 'evidence'> & { version: string };
 export type AuthorQueueRow = Pick<QueueItem, 'seat' | 'status'> & Partial<Pick<QueueItem, 'input' | 'kind'>>;
 export type AuthorDepthResult = {
   seats: Array<{ seat: OrchestratorSeat; cap: number | null; running: number | null; queued: number | null;
     target: number | null; short: number | null; wouldAuthor: Array<{ cellId: string; version: string; title: string }> }>;
   unreadable: Array<{ source: string; reason: string }>;
+  receiptCounts?: { held: number; queuedForAuthor: number };
+  receiptFailures?: number;
 };
 export type AuthorDepthInput = {
   seats: readonly OrchestratorSeat[];
@@ -84,6 +90,7 @@ export function authorDepth({ seats, caps, running, queued, cells, overlaps, now
 }
 
 export interface CollectAuthorDepthDeps {
+  root?: string;
   seats?: readonly OrchestratorSeat[];
   now?: Date;
   caps?: () => Partial<Record<OrchestratorSeat, number>>;
@@ -92,12 +99,13 @@ export interface CollectAuthorDepthDeps {
   cells?: (version: string) => readonly AuthorCell[];
   overlaps?: () => readonly WorkItem[];
   versions?: () => readonly [string, string];
+  ledger?: Pick<AuthorLedger, 'request'>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
 }
 
-function defaultVersions(now: Date): readonly [string, string] {
-  if (!existsSync(join(releaseLedgerRoot(), 'release', 'features.sqlite'))) throw new Error('release schedule ledger unavailable');
-  const upcoming = listSchedules().filter(row => row.cutAt && Date.parse(row.cutAt) > now.getTime())
+function defaultVersions(now: Date, root = releaseLedgerRoot()): readonly [string, string] {
+  if (!existsSync(join(root, 'release', 'features.sqlite'))) throw new Error('release schedule ledger unavailable');
+  const upcoming = listSchedules(root).filter(row => row.cutAt && Date.parse(row.cutAt) > now.getTime())
     .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
   if (upcoming.length < 2) throw new Error('current and next release schedules unavailable');
   return [upcoming[0]!.version, upcoming[1]!.version];
@@ -123,12 +131,13 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
     if (measured.unassigned) throw new Error(`${measured.unassigned} unassigned harness launch process(es)`);
     return Object.fromEntries(measured.seats.map(row => [row.seat, row.running]));
   });
-  const queued = observe('queue', deps.queued ?? (() => listHarnessQueue()));
-  const versions = observe('versions', deps.versions ?? (() => defaultVersions(now)));
+  const queued = observe('queue', deps.queued ?? (() => listHarnessQueue({ root: deps.root })));
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const versions = observe('versions', deps.versions ?? (() => defaultVersions(now, releaseRoot)));
   const cells = versions === null ? null : observe('checklist', () => versions.flatMap(version => {
-    if (!deps.cells && !existsSync(join(releaseLedgerRoot(), 'release', 'features.sqlite')))
+    if (!deps.cells && !existsSync(join(releaseRoot, 'release', 'features.sqlite')))
       throw new Error('checklist ledger unavailable');
-    return deps.cells?.(version) ?? listChecklist(version).items.map(item => ({ ...item, version }));
+    return deps.cells?.(version) ?? listChecklist(version, deps.root).items.map(item => ({ ...item, version }));
   }));
   const overlaps = observe('overlap', deps.overlaps ?? (() => {
     const observed = collectWork();
@@ -141,9 +150,56 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
   for (const row of result.seats) log('loop.orchestrator', 'would-author', {
     seat: row.seat, target: row.target, have: row.queued, short: row.short, cells: row.wouldAuthor,
   });
+  const ledger = deps.ledger ?? new AuthorLedger(deps.root === undefined ? {} : { path: join(deps.root, 'orchestrator', 'author-ledger.sqlite') });
+  const receiptCounts = { held: 0, queuedForAuthor: 0 };
+  let receiptFailures = 0;
+  for (const row of result.seats) for (const candidate of row.wouldAuthor) {
+    const cell = cells?.find(item => item.id === candidate.cellId && item.version === candidate.version);
+    try {
+      if (!cell) throw new Error('selected cell unavailable');
+      const text = cell.evidence ?? '';
+      const check = checkAuthorInput({ title: cell.title, text, cellId: cell.id, version: cell.version });
+      const receipt = ledger.request({ seat: row.seat, cellId: cell.id, version: cell.version, title: cell.title,
+        text, check: { verdict: check.verdict, signals: check.signals, ratio: check.implementationRatio } });
+      if (receipt.status === 'held') receiptCounts.held++;
+      if (receipt.status === 'queued-for-author') receiptCounts.queuedForAuthor++;
+    } catch (error) {
+      receiptFailures++;
+      result.unreadable.push({ source: 'author-ledger', reason: `${candidate.version} ${candidate.cellId}: ${error instanceof Error ? error.message : String(error)}` });
+    }
+  }
+  result.receiptCounts = receiptCounts;
+  result.receiptFailures = receiptFailures;
   return result;
 }
 
+const SHADOW_INTERVAL_MS = 30 * 60_000;
+
+/** The queue tick serializes callers; stamp before collection so even a failing shadow cannot run every two minutes. */
+export function runAuthorDepthShadow(root = effectiveInstanceRoot(), now = new Date(), collect = collectAuthorDepth): void {
+  const path = join(root, 'orchestrator', 'author-depth-shadow-at');
+  const time = now.getTime();
+  if (!Number.isFinite(time)) throw new Error('invalid author-depth shadow clock');
+  if (existsSync(path)) {
+    const last = Date.parse(readFileSync(path, 'utf8').trim());
+    if (!Number.isFinite(last)) throw new Error('invalid author-depth shadow marker');
+    if (time - last < SHADOW_INTERVAL_MS) return;
+  }
+  mkdirSync(join(root, 'orchestrator'), { recursive: true });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, now.toISOString(), { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, path);
+  } catch (error) {
+    try { unlinkSync(temporary); } catch { /* No temporary file to remove. */ }
+    throw error;
+  }
+  const result = collect({ root, now });
+  if (result.unreadable.length || result.receiptFailures || !result.receiptCounts) {
+    throw new Error(`author-depth shadow incomplete: ${JSON.stringify({ unreadable: result.unreadable, receiptFailures: result.receiptFailures })}`);
+  }
+}
+
 export function authorDepthLines(result: AuthorDepthResult): string[] {
   return result.seats.map(row => `${row.seat} ${row.running ?? '?'}/${row.cap ?? '?'} · 대기 ${row.queued ?? '?'} · 목표 ${row.target ?? '?'} · 모자람 ${row.short ?? '?'} → ${row.wouldAuthor.map(cell => cell.cellId).join(', ') || '없음'}`);
 }

package/src/loops/orchestrator/author-input-check.ts

@@ -8,7 +8,7 @@ export interface AuthorInput {
 }
 
 export interface AuthorInputSignal {
-  kind: 'path' | 'symbol' | 'command' | 'marker';
+  kind: 'path' | 'symbol' | 'command' | 'marker' | 'missing';
   match: string;
   field: 'title' | 'text';
   reason: string;
@@ -40,15 +40,19 @@ function sentences(value: string): string[] {
 }
 
 export function checkAuthorInput({ title, text, cellId, version }: AuthorInput): AuthorInputCheck {
-  const valid = [title, text, cellId, version].every(value => typeof value === 'string' && !!value.trim())
+  const validIdentity = [title, cellId, version].every(value => typeof value === 'string' && !!value.trim())
     && /^\d+\.\d+\.\d+$/.test(version);
+  const missingText = typeof text !== 'string' || !text.trim();
+  const valid = validIdentity && !missingText;
   const signals: AuthorInputSignal[] = [];
+  if (validIdentity && missingText) signals.push({ kind: 'missing', match: '', field: 'text', reason: 'missing cell text' });
   let checked = 0;
   let candidates = 0;
   let directed = false;
 
-  if (valid) {
+  if (validIdentity) {
     for (const field of ['title', 'text'] as const) {
+      if (field === 'text' && missingText) continue;
       for (const sentence of sentences(field === 'title' ? title : text)) {
         checked++;
         let found = false;
@@ -70,6 +74,7 @@ export function checkAuthorInput({ title, text, cellId, version }: AuthorInput):
   const verdict: AuthorInputCheck['verdict'] = !valid ? 'uncheckable'
     : signals.length === 0 ? 'approved' : directed ? 'resubmit' : 'confirm';
   const implementationRatio = valid ? candidates / checked : null;
+  if (!valid) { checked = 0; candidates = 0; }
   debug.log('author.par', 'input-checked', {
     cellId, version, verdict, signals: signals.length, ratio: implementationRatio,
   });

package/src/loops/orchestrator/author-ledger.ts

@@ -120,9 +120,11 @@ export class AuthorLedger {
   }
 
   request(input: AuthorRequest): AuthorRow & { duplicate: boolean } {
-    for (const key of ['seat', 'cellId', 'version', 'title', 'text'] as const) {
+    for (const key of ['seat', 'cellId', 'version', 'title'] as const) {
       if (typeof input[key] !== 'string' || !input[key].trim()) throw new Error(`${key} is required`);
     }
+    if (typeof input.text !== 'string' || (!input.text.trim() && input.check?.verdict !== 'uncheckable'))
+      throw new Error('text is required unless uncheckable');
     if (!['approved', 'resubmit', 'confirm', 'uncheckable'].includes(input.check?.verdict)
       || !Array.isArray(input.check.signals)
       || (input.check.ratio !== null && (typeof input.check.ratio !== 'number' || !Number.isFinite(input.check.ratio))))

package/src/loops/orchestrator/finish-rate.ts

@@ -6,6 +6,8 @@ import { loadRunLedger, resolveFederatedRunLedgerTargets } from '../../self-impl
 import type { LogTarget } from '../../cli/logs-cli.js';
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
+/** Host-side records a Pod-dispatched launch leaves when its run starts inside the Pod. */
+const LAUNCH_ONLY_EVENTS = new Set(['launch-quota-policy', 'author-on-pod-receipt']);
 const GH_LIMIT = 1000;
 
 export type FinishMetric = 'launched' | 'landed' | 'landingRate' | 'staleDrafts' | 'conflictRatio' | 'unknownMergeable';
@@ -38,6 +40,7 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
   const childLedgers = new Set<string>();
   let unreadableDirectories = 0;
   let unresolvedDirectories = 0;
+  const launchOnlyIds = new Set<string>();
   for (const { ledgerDirectory } of resolveFederatedRunLedgerTargets({ includeTest: true, ...(targets ? { targets } : {}) })) {
     let dir: string;
     try {
@@ -68,16 +71,24 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
         continue;
       }
       const start = entries.find(entry => entry.event === 'start');
-      if (!start?.timestamp) {
+      // A Pod-dispatched launch leaves only a host launch record (launch-quota-policy · author-on-pod-receipt) — the run
+      // itself starts inside the Pod. That is still a launch: its time is the record's timestamp, else the ledger mtime.
+      const launchRecord = !start ? entries.find(entry => LAUNCH_ONLY_EVENTS.has(entry.event)) : undefined;
+      const startedAt = start?.timestamp ?? (launchRecord ? (launchRecord.timestamp ?? new Date(statSync(path).mtimeMs).toISOString()) : undefined);
+      if (!startedAt) {
         if (!starts.has(runId)) unreadable.set(runId, { runId, reason: entries[0]?.event ?? 'start missing' });
         continue;
       }
-      starts.set(runId, { runId, startedAt: start.timestamp });
+      // One runId can leave a host launch record in one directory and a Pod `start` in another: a real `start`
+      // always wins and is never overwritten by a launch record, whatever order the directories are read in.
+      if (launchRecord && starts.has(runId)) continue;
+      if (launchRecord) launchOnlyIds.add(runId); else launchOnlyIds.delete(runId);
+      starts.set(runId, { runId, startedAt });
       unreadable.delete(runId);
     }
   }
   debug.log('loop.orchestrator', 'finish-launch-population', {
-    directories: directories.size + unresolvedDirectories, launched: starts.size, childLedgers: childLedgers.size, unreadable: unreadable.size,
+    directories: directories.size + unresolvedDirectories, launched: starts.size, launchOnly: launchOnlyIds.size, childLedgers: childLedgers.size, unreadable: unreadable.size,
   });
   return { starts: [...starts.values()], unreadable: [...unreadable.values()], unreadableDirectories };
 }