elanous 0.2.15 → 0.2.16

package/src/intake-plane/digest.ts

@@ -6,7 +6,8 @@ import { loadIntakeLedger, type IntakeItem } from './items.js';
 import { readSavedCursorAt } from './collect-telegram-saved.js';
 import { intakeOutboxDir, kstDay } from './route.js';
 
-export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string; impact?: { fact: string; current: string; action: string } }
+export type DigestLensVerdict = '대체 후보' | '보강' | '경쟁 대조';
+export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string; impact?: { verdict: DigestLensVerdict; why: string; target: string } }
 export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
 
 const AXIS_LABEL: Record<string, string> = {
@@ -40,27 +41,32 @@ function readJsonl(file: string): Record<string, unknown>[] {
 /** Saved Messages silent for more than two days → the digest says so (a quiet 0 must not look like «nothing to do»). */
 const SAVED_SILENCE_MS = 48 * 3600_000;
 
+/** A «why» that only names paths (optionally behind a label like «경로:») is evidence, not a reason for us. */
+export function pathOnly(why: string): boolean {
+  const rest = why
+    .replace(/`?(?:[\w.-]+\/)*[\w.-]+\.[A-Za-z0-9]{1,6}(?::\d+)?`?/g, ' ')
+    .replace(/`?(?:[\w.-]+\/)+[\w.-]*`?/g, ' ')
+    .replace(/(?:경로|파일|근거|path|file|evidence)\s*[:：]?/gi, ' ')
+    .replace(/[\s,·:;()[\]\-–—]+/g, '');
+  return rest.length < 4;
+}
+
 export function buildIntakeDigest(root: string, day: string, readFile: (p: string) => string | undefined = (p) => (existsSync(p) ? readFileSync(p, 'utf8') : undefined), now: Date = new Date()): IntakeDigest {
   const items = [...loadIntakeLedger(root).items.values()]
     .filter((i) => (i.status === 'absorbed' || i.status === 'routed') && kstDay(i.lastSeenAt) === day && i.outputs.some((o) => o.kind === 'note'));
   const out = intakeOutboxDir(root);
   const relevant = new Map<string, NonNullable<DigestEntry['impact']>>();
-  for (const [folder, action] of [
-    ['goals', '없는 기능의 골 후보를 세운다'],
-    ['manual', '문서·약속을 현재 동작에 맞게 보강한다'],
-    ['review', '대조 근거를 추가로 확인한다'],
-    ['release', '이미 착지한 기능의 바깥 맥락을 릴리스 노트에 반영한다'],
-  ] as const) {
+  // The lens (src/intake-plane/lens.ts) writes its verdicts to outbox/lens/<day>.jsonl; route folders carry none.
+  for (const folder of ['lens'] as const) {
     for (const row of readJsonl(join(out, folder, `${day}.jsonl`))) {
       if (typeof row.id !== 'string' || relevant.has(row.id)) continue;
-      const fact = folder === 'release' ? row.title : row.fact;
-      if (typeof fact !== 'string' || !fact.trim()) continue;
-      relevant.set(row.id, {
-        fact,
-        current: typeof (folder === 'release' ? row.summary : row.current) === 'string'
-          ? String(folder === 'release' ? row.summary : row.current) : '대조 근거 없음',
-        action,
-      });
+      const verdict = row.lensVerdict;
+      if (verdict !== '대체 후보' && verdict !== '보강' && verdict !== '경쟁 대조') continue;
+      const why = typeof row.why === 'string' ? row.why.trim() : '';
+      const target = typeof row.target === 'string' ? row.target.trim() : '';
+      // A check's fact/current or repo path is evidence, not a lens judgement or a reason for us.
+      if (!why || !target || pathOnly(why)) continue;
+      relevant.set(row.id, { verdict, why, target });
     }
   }
   const absorbed = items.map((i: IntakeItem): DigestEntry => {
@@ -105,29 +111,45 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
     for (const g of d.goals.slice(0, 10)) L.push(`- ${g.fact}${g.url ? ` · [원본](${g.url})` : ''}`);
     L.push('');
   }
-  if (d.review?.length) {
-    L.push(`### 🟡 사람이 가를 것 — 판단 필요 (${d.review.length})`, '', '> 근거가 실행 코드에 닿지만 «같은 것인가»는 결정론으로 못 가른다 — 노트의 🧭 절에서 판단한다.', '');
-    for (const r of d.review.slice(0, 10)) L.push(`- ${r.fact}${r.note ? ` · [[${basename(r.note, '.md')}]]` : ''}`);
-    if (d.review.length > 10) L.push(`- … 외 ${d.review.length - 10}건`);
-    L.push('');
-  }
+  const undecided = d.absorbed.filter((e) => !e.impact).length;
+  if (undecided) L.push(`렌즈 판정 못 함 ${undecided} — 원장 \`elanous intake items\``, '');
   L.push(`> 매뉴얼 후보 ${d.manual} · 릴리스 노트 맥락 ${d.release} · 그라운딩 후보 ${d.grounding} — 흡수 원장 \`elanous intake items\` · 큐 \`<인스턴스>/intake/outbox/\``, '');
   return L.join('\n');
 }
 
 /** 텔레그램 — 흡수 렌즈가 대조한 항목만 SCQA 짧은 판으로 낸다. */
 export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: string; notePath?: string } = {}): string {
+  // «Touching» is decided by the lens verdict alone; a missing note summary only changes how S reads (ACP must-fix).
   const touching = d.absorbed.filter((e) => e.impact);
   const L = [`흡수 ${d.absorbed.length} → 우리에게 닿는 것 ${touching.length}`];
   if (!touching.length) return L[0];
-  for (const e of touching.slice(0, 3)) {
+  // At most three items are shown, each as its own S·C·A·link block so context and source stay paired;
+  // a later item sharing (verdict, target) says «위와 같은 행동» instead of repeating the A sentence (ACP must-fix).
+  // S must be the note's own summary: items without one still count as touching but are not shown (ACP must-fix).
+  const shownItems = touching.filter((e) => e.oneLiner?.trim()).slice(0, 3);
+  const actionSeen = new Set<string>();
+  const actionsUsed = new Set<string>();
+  for (const e of shownItems) {
+    const impact = e.impact!;
+    const key = `${impact.verdict}\u0000${impact.target}`;
+    const base = impact.verdict === '대체 후보' ? `${impact.target} lite Pod 실증 제안`
+      : impact.verdict === '보강' ? `칸 ${impact.target} 에 근거 추가`
+        : `${impact.target} 비교표 갱신`;
+    // Every item keeps its own concrete action; a repeat of (verdict, target) names which item it is, so no two A lines match.
+    const label = (e.oneLiner?.trim() || impact.why).slice(0, 24);
+    let action = actionSeen.has(key) ? `${base} — «${label}» 근거로` : base;
+    // Two identical labels still differ by their position in the list.
+    if (actionsUsed.has(action)) action = `${action} (${shownItems.indexOf(e) + 1})`;
+    actionsUsed.add(action);
+    actionSeen.add(key);
     L.push('',
-      `S 무엇: ${e.impact!.fact}`,
-      `C 우리에게 왜: ${e.impact!.current}`,
-      `A 그래서 무엇을 하나: ${e.impact!.action}`,
+      `S 무엇: ${e.oneLiner?.trim() || '노트 한 줄 요약 없음'}`,
+      `C 우리에게 왜: ${impact.why}`,
+      `A 그래서 무엇을 하나: ${action}`,
       `🔗 원문 링크: ${e.url?.trim() || '링크 없음'}`,
     );
   }
-  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 닿지 않음`);
+  if (touching.length > shownItems.length) L.push('', `닿는 것 ${touching.length - shownItems.length}건 더(요약 없는 것 포함) · 원장 \`elanous intake items\``);
+  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 참고`);
   return L.join('\n');
 }

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/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 };
 }