elanous 0.2.0 → 0.2.4

package/src/self-implement/run-ledger.ts

@@ -1,5 +1,5 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { tracedPathReferences, verbatimOriginalAsk } from './goal-author.js';
 import { parseAskTargetPathHintsResult } from '../self-dev/launch-preflight.js';
 import { isRunStatus } from './run-status-mapping.js';
@@ -10,6 +10,8 @@ import { LogStore, logsDbPath, type LogStoreRow } from '../mss/logging/log-store
 import { loadSelfDevRun, selfDevRunsDir } from '../self-dev/run-store.js';
 import { extractHarnessReviewAcceptance } from '../harness/harness-seams.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
+import { debug } from '../debug/log.js';
+import { withRunLedgerLock, restoreArchivedRunLedger } from './run-ledger-compact.js';
 
 export interface RunLedgerEntry {
   timestamp?: string;
@@ -401,7 +403,11 @@ export function describeFederatedMissingRunLedger(runId: string, options: Federa
 /** Append one observer event. Callers own fail-soft handling. */
 export function appendRunLedgerEntry(entry: RunLedgerEntry, dir = runLedgerDir()): void {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  appendFileSync(runLedgerPath(entry.runId, dir), `${JSON.stringify(entry)}\n`, 'utf8');
+  const live = runLedgerPath(entry.runId, dir);
+  withRunLedgerLock(dir, entry.runId, () => {
+    const line = `${JSON.stringify(entry)}\n`;
+    if (!restoreArchivedRunLedger(dir, entry.runId, line)) appendFileSync(live, line, 'utf8');
+  });
 }
 
 export interface HumanStopRunLedgerOptions {
@@ -1189,7 +1195,9 @@ export interface UnfinishedRunLedgerEntry {
   /** Union of declared and traced paths, with the axis that caused each path to match. */
   pathMatchReasons: Readonly<Record<string, UnfinishedRunPathMatchReason>>;
   goalDocumentPath: string | null;
-  /** Directory searched only when legacy branch-suffix fallback was used. */
+  /** Produced by ledger queries; optional for existing callers constructing projected entries. */
+  goalLookupBasis?: 'ledger-target' | 'caller-cwd';
+  /** Directory searched only when branch-suffix fallback was used. */
   goalDocumentSearchDirectory: string | null;
   lastActivityTimestamp: string | null;
   lastActivityAgeMs: number | null;
@@ -1204,6 +1212,10 @@ export interface UnfinishedRunLedgerQuery {
   goalsDirectory: string;
   unreadableLedgerCount: number;
   ledgerDirectoryMissing: boolean;
+  /** Ledgers the last-line rule would miss and the trailing-bookkeeping rule counts as terminal. */
+  terminalByTrailingRunStatus?: number;
+  cacheHits?: number;
+  cacheMisses?: number;
   pathFilter?: string;
   matchingPathCount?: number;
   unknownPathCount?: number;
@@ -1217,6 +1229,7 @@ export interface UnfinishedRunLedgerQueryOptions {
   path?: string;
   read?: RunLedgerReader;
   list?: (path: string) => string[];
+  noCache?: boolean;
   /** ⛔ 「도는 중」으로 볼 마지막 활동 나이(ms). 호출자가 준다 — 이 모듈이 새 수를 정하지 않는다. */
   liveWindowMs?: number;
 }
@@ -1274,13 +1287,46 @@ function hasCanonicalRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
   return ledger.some((entry) => entry.event === 'run-status' && isRunStatus(entry.data.runStatus));
 }
 
-function hasTerminalRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
+/** Events that may follow a terminal run-status without reopening the run. Anything else stays unfinished. */
+export const TRAILING_BOOKKEEPING_EVENTS = ['pipeline-traversal-shadow', 'run-rollup', 'progress-delivery', 'progress-delivery-outcome'] as const;
+
+const TRAILING_BOOKKEEPING_EVENT_SET = new Set<string>(TRAILING_BOOKKEEPING_EVENTS);
+
+function lastValidRunStatusIndex(ledger: readonly RunLedgerEntry[]): number {
+  for (let index = ledger.length - 1; index >= 0; index -= 1) {
+    const entry = ledger[index]!;
+    if (entry.event === 'run-status' && isRunStatus(entry.data.runStatus)) return index;
+  }
+  return -1;
+}
+
+/** True when the last line is itself a valid run-status (the previous terminator). */
+function lastLineIsValidRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
   const lastEntry = ledger.at(-1);
-  return (lastEntry?.event === 'run-status' && isRunStatus(lastEntry.data.runStatus))
+  return lastEntry?.event === 'run-status' && isRunStatus(lastEntry.data.runStatus);
+}
+
+/**
+ * Terminal when the last valid run-status is followed only by trailing bookkeeping,
+ * or when a `terminal` / `human-stop` event is present anywhere.
+ * A later event outside the bookkeeping list keeps the run unfinished.
+ */
+export function hasTerminalRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
+  const statusIndex = lastValidRunStatusIndex(ledger);
+  const trailingOnly = statusIndex >= 0
+    && ledger.slice(statusIndex + 1).every((entry) => TRAILING_BOOKKEEPING_EVENT_SET.has(entry.event));
+  return trailingOnly
     || hasNonCanonicalTerminalEvent(ledger)
     || hasHumanStopEvent(ledger);
 }
 
+/** Last-line rule would miss this ledger, but the trailing-bookkeeping rule counts it terminal. */
+function isTerminalOnlyByTrailingRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
+  return hasTerminalRunStatus(ledger) && !lastLineIsValidRunStatus(ledger)
+    && !hasNonCanonicalTerminalEvent(ledger)
+    && !hasHumanStopEvent(ledger);
+}
+
 /** ⛔⭐⭐⭐ 미완 항목의 «상태» — 종전엔 이 조회가 낸 것이 «한 값»(`terminal-status-missing`)뿐이었다.
  *  📏 2026-08-11 실측: 그 한 값 안에 서로 «다른 것»이 섞여 있었다 —
  *     실제로 도는 것 2 · 오래 전에 죽은 잔해 51(중앙 5.2일) · 종료를 «다른 이름»으로 적은 것 5.
@@ -1471,6 +1517,11 @@ function ledgerGoalDocument(ledger: readonly RunLedgerEntry[]): string | null {
   return null;
 }
 
+function ledgerTargetRoot(ledger: readonly RunLedgerEntry[]): string | null {
+  const targetRoot = ledger.find((entry) => entry.event === 'start')?.data.targetRoot;
+  return typeof targetRoot === 'string' && isAbsolute(targetRoot) ? targetRoot : null;
+}
+
 function pathMatchReasons(declaredPaths: readonly string[], tracedPaths: readonly string[]): Readonly<Record<string, UnfinishedRunPathMatchReason>> {
   const declared = new Set(declaredPaths);
   const traced = new Set(tracedPaths);
@@ -1493,16 +1544,87 @@ function unknownDeclaredPaths(): Pick<UnfinishedRunLedgerEntry, 'declaredPaths'
   return { declaredPaths: [], declaredPathStatus: 'unknown' };
 }
 
-function lastActivity(ledger: readonly RunLedgerEntry[]): Pick<UnfinishedRunLedgerEntry, 'lastActivityTimestamp' | 'lastActivityAgeMs' | 'lastActivityStatus'> {
-  const timestamp = ledger.at(-1)?.timestamp;
-  if (timestamp === undefined) return { lastActivityTimestamp: null, lastActivityAgeMs: null, lastActivityStatus: 'timestamp-missing' };
-  const time = Date.parse(timestamp);
-  if (!Number.isFinite(time)) return { lastActivityTimestamp: null, lastActivityAgeMs: null, lastActivityStatus: 'timestamp-invalid' };
-  return { lastActivityTimestamp: timestamp, lastActivityAgeMs: Date.now() - time, lastActivityStatus: 'available' };
+interface UnfinishedLedgerFacts {
+  terminal: boolean;
+  terminalByTrailingRunStatus: boolean;
+  branch: string | null;
+  lastActivityTimestamp: string | null;
+  lastActivityStatus: LastActivityStatus;
+  targetRoot: string | null;
+  goalFile: string | null;
+  fixedLifecycle: UnfinishedRunLifecycle;
+}
+
+const UNFINISHED_LEDGER_CACHE_LIMIT = 5_000;
+const unfinishedLedgerCache = new Map<string, { size: number; mtimeMs: number; facts: UnfinishedLedgerFacts }>();
+const unfinishedReaderIds = new WeakMap<RunLedgerReader, number>();
+let nextUnfinishedReaderId = 1;
+
+function unfinishedLedgerCacheKey(path: string, read?: RunLedgerReader): string {
+  if (!read) return `${path}\u0000default`;
+  let id = unfinishedReaderIds.get(read);
+  if (id === undefined) {
+    id = nextUnfinishedReaderId++;
+    unfinishedReaderIds.set(read, id);
+  }
+  return `${path}\u0000reader:${id}`;
+}
+
+function unfinishedLedgerFacts(ledger: readonly RunLedgerEntry[]): UnfinishedLedgerFacts {
+  const last = ledger.at(-1)?.timestamp;
+  const lastActivityTimestamp = last !== undefined && Number.isFinite(Date.parse(last)) ? last : null;
+  return {
+    terminal: hasTerminalRunStatus(ledger),
+    terminalByTrailingRunStatus: isTerminalOnlyByTrailingRunStatus(ledger),
+    branch: branchFromLedger(ledger),
+    lastActivityTimestamp,
+    lastActivityStatus: last === undefined ? 'timestamp-missing' : lastActivityTimestamp === null ? 'timestamp-invalid' : 'available',
+    targetRoot: ledgerTargetRoot(ledger),
+    goalFile: ledgerGoalDocument(ledger),
+    fixedLifecycle: classifyUnfinishedLifecycle(ledger, null, 0),
+  };
+}
+
+function readUnfinishedLedgerFacts(runId: string, dir: string, read?: RunLedgerReader, noCache?: boolean): { facts: UnfinishedLedgerFacts; hit: boolean } {
+  const path = runLedgerPath(runId, dir);
+  const key = noCache ? null : unfinishedLedgerCacheKey(path, read);
+  const stamp = noCache ? null : statSync(path);
+  const cached = key === null ? undefined : unfinishedLedgerCache.get(key);
+  if (cached && stamp && key !== null && cached.size === stamp.size && cached.mtimeMs === stamp.mtimeMs) {
+    unfinishedLedgerCache.delete(key);
+    unfinishedLedgerCache.set(key, cached);
+    return { facts: cached.facts, hit: true };
+  }
+  if (key !== null) unfinishedLedgerCache.delete(key);
+  try {
+    const ledger = loadRunLedger(runId, dir, read);
+    if (ledger === null && stamp !== null) throw new Error(`run ledger disappeared after stat: ${path}`);
+    const facts = unfinishedLedgerFacts(ledger ?? []);
+    if (stamp !== null && key !== null) {
+      const after = statSync(path);
+      if (after.size === stamp.size && after.mtimeMs === stamp.mtimeMs) {
+        unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts });
+        if (unfinishedLedgerCache.size > UNFINISHED_LEDGER_CACHE_LIMIT) unfinishedLedgerCache.delete(unfinishedLedgerCache.keys().next().value!);
+      }
+    }
+    return { facts, hit: false };
+  } catch (error) {
+    if (key !== null) unfinishedLedgerCache.delete(key);
+    throw error;
+  }
+}
+
+function unfinishedActivity(facts: UnfinishedLedgerFacts): Pick<UnfinishedRunLedgerEntry, 'lastActivityTimestamp' | 'lastActivityAgeMs' | 'lastActivityStatus'> {
+  return {
+    lastActivityTimestamp: facts.lastActivityTimestamp,
+    lastActivityStatus: facts.lastActivityStatus,
+    lastActivityAgeMs: facts.lastActivityTimestamp === null ? null : Date.now() - Date.parse(facts.lastActivityTimestamp),
+  };
 }
 
 /** Read non-terminal ledgers and their declared planned paths without changing any run, ledger, or goal document. */
 export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptions = {}): UnfinishedRunLedgerQuery {
+  const startedAt = Date.now();
   const dir = resolve(options.dir ?? runLedgerDir());
   const goalsDir = resolve(options.goalsDir ?? resolveGoalDocumentsDir(process.cwd()).directory);
   const list = options.list ?? readdirSync;
@@ -1512,42 +1634,81 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     fileNames = list(dir);
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      return {
+      const missing: UnfinishedRunLedgerQuery = {
         entries: [],
         ledgerDirectory: dir,
         goalsDirectory: goalsDir,
         unreadableLedgerCount: 0,
         ledgerDirectoryMissing: true,
+        terminalByTrailingRunStatus: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
         ...(options.path === undefined ? {} : { pathFilter: options.path, matchingPathCount: 0, unknownPathCount: 0 }),
         scope: 'self-implement-run-ledger',
         note: UNFINISHED_RUN_LEDGER_NOTE,
       };
+      debug.log('self-implement.run-ledger', 'goal-lookup-basis', { ledgerTarget: 0, callerCwd: 0 });
+      debug.log('self-implement.run-ledger', 'unfinished-query', {
+        scanned: 0,
+        terminal: 0,
+        unfinished: 0,
+        terminalByTrailingRunStatus: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        ms: Date.now() - startedAt,
+      });
+      return missing;
     }
     throw error;
   }
 
   const entries: UnfinishedRunLedgerEntry[] = [];
   let unreadableLedgerCount = 0;
+  let scanned = 0;
+  let terminal = 0;
+  let terminalByTrailingRunStatus = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  let ledgerTargetCount = 0;
+  let callerCwdCount = 0;
   for (const fileName of fileNames) {
     const runId = runIdFromCanonicalLedgerFile(fileName);
     if (!runId) continue;
-    let ledger: RunLedgerEntry[];
+    scanned += 1;
+    let facts: UnfinishedLedgerFacts;
     try {
-      ledger = loadRunLedger(runId, dir, options.read) ?? [];
+      const observed = readUnfinishedLedgerFacts(runId, dir, options.read, options.noCache);
+      facts = observed.facts;
+      if (observed.hit) cacheHits += 1;
+      else cacheMisses += 1;
     } catch {
+      cacheMisses += 1;
       unreadableLedgerCount += 1;
-      entries.push({ runId, branch: null, status: 'ledger-unreadable', plannedPaths: [], plannedPathStatus: 'unknown', ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalDocumentSearchDirectory: null, lastActivityTimestamp: null, lastActivityAgeMs: null, lastActivityStatus: 'ledger-unreadable', lifecycle: 'unjudgeable' });
+      entries.push({ runId, branch: null, status: 'ledger-unreadable', plannedPaths: [], plannedPathStatus: 'unknown', ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis: 'caller-cwd', goalDocumentSearchDirectory: null, lastActivityTimestamp: null, lastActivityAgeMs: null, lastActivityStatus: 'ledger-unreadable', lifecycle: 'unjudgeable' });
+      callerCwdCount += 1;
+      continue;
+    }
+    if (facts.terminal) {
+      terminal += 1;
+      if (facts.terminalByTrailingRunStatus) terminalByTrailingRunStatus += 1;
       continue;
     }
-    if (hasTerminalRunStatus(ledger)) continue;
 
-    const branch = branchFromLedger(ledger);
-    const activity = lastActivity(ledger);
-    const ledgerGoalFile = ledgerGoalDocument(ledger);
+    const branch = facts.branch;
+    const activity = unfinishedActivity(facts);
+    const lifecycle = facts.fixedLifecycle === 'unjudgeable' && activity.lastActivityAgeMs !== null
+      ? activity.lastActivityAgeMs <= liveWindowMs ? 'live' : 'orphaned'
+      : facts.fixedLifecycle;
+    const targetRoot = facts.targetRoot;
+    const goalLookupBasis = targetRoot === null ? 'caller-cwd' : 'ledger-target';
+    if (targetRoot === null) callerCwdCount += 1;
+    else ledgerTargetCount += 1;
+    const ledgerGoalFile = facts.goalFile;
+    const searchDirectory = ledgerGoalFile ? null : targetRoot === null ? goalsDir : resolveGoalDocumentsDir(targetRoot).directory;
     const goalDocument = ledgerGoalFile
-      ? { status: 'found' as const, path: ledgerGoalFile, source: 'ledger' as const }
+      ? { status: 'found' as const, path: targetRoot !== null && !isAbsolute(ledgerGoalFile) ? resolve(targetRoot, ledgerGoalFile) : ledgerGoalFile, source: 'ledger' as const }
       : (() => {
-        const fallback = goalDocumentForBranch(branch, goalsDir, list);
+        const fallback = goalDocumentForBranch(branch, searchDirectory ?? goalsDir, list);
         return fallback.status === 'found' ? { ...fallback, source: 'branch' as const } : fallback;
       })();
     if (goalDocument.status !== 'found') {
@@ -1558,7 +1719,7 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
           : goalDocument.status === 'directory-unreadable'
             ? 'goal-directory-unreadable'
             : 'goal-document-not-found';
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalDocumentSearchDirectory: ledgerGoalFile ? null : goalsDir, ...activity, lifecycle: classifyUnfinishedLifecycle(ledger, activity.lastActivityAgeMs, liveWindowMs) });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
       continue;
     }
     try {
@@ -1566,14 +1727,24 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
       const text = typeof document === 'string' ? document : document.toString('utf8');
       const paths = [...new Set(tracedPathReferences(text).map((reference) => reference.path))];
       const declared = declaredPathsFromGoalDocument(text);
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalDocumentSearchDirectory: goalDocument.source === 'branch' ? goalsDir : null, ...activity, lifecycle: classifyUnfinishedLifecycle(ledger, activity.lastActivityAgeMs, liveWindowMs) });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
     } catch {
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalDocumentSearchDirectory: goalDocument.source === 'branch' ? goalsDir : null, ...activity, lifecycle: classifyUnfinishedLifecycle(ledger, activity.lastActivityAgeMs, liveWindowMs) });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
     }
   }
   entries.sort((left, right) => left.runId.localeCompare(right.runId));
+  debug.log('self-implement.run-ledger', 'goal-lookup-basis', { ledgerTarget: ledgerTargetCount, callerCwd: callerCwdCount });
+  debug.log('self-implement.run-ledger', 'unfinished-query', {
+    scanned,
+    terminal,
+    unfinished: entries.length,
+    terminalByTrailingRunStatus,
+    cacheHits,
+    cacheMisses,
+    ms: Date.now() - startedAt,
+  });
   if (options.path === undefined) {
-    return { entries, ledgerDirectory: dir, goalsDirectory: goalsDir, unreadableLedgerCount, ledgerDirectoryMissing: false, scope: 'self-implement-run-ledger', note: UNFINISHED_RUN_LEDGER_NOTE };
+    return { entries, ledgerDirectory: dir, goalsDirectory: goalsDir, unreadableLedgerCount, ledgerDirectoryMissing: false, terminalByTrailingRunStatus, cacheHits, cacheMisses, scope: 'self-implement-run-ledger', note: UNFINISHED_RUN_LEDGER_NOTE };
   }
   const pathFilter = options.path;
   const unknownPathStatus = (entry: UnfinishedRunLedgerEntry): boolean => entry.plannedPathStatus !== 'found-ledger-goal-file'
@@ -1590,6 +1761,9 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     goalsDirectory: goalsDir,
     unreadableLedgerCount,
     ledgerDirectoryMissing: false,
+    terminalByTrailingRunStatus,
+    cacheHits,
+    cacheMisses,
     pathFilter,
     matchingPathCount: matchingEntries.length,
     unknownPathCount: unknownEntries.length,
@@ -1625,6 +1799,8 @@ export interface FederatedUnfinishedRunLedgerQuery {
   /** ⭐ 가로 대조로 «미완에서 빠진» 런 수 — 다른 원장에 종결이 있어 제외된 것.
    *  ⛔ 「0 건」과 「대조를 안 했다」를 같은 값으로 두지 않으려고 «항상» 싣는다. */
   reconciledTerminatedElsewhereCount: number;
+  cacheHits?: number;
+  cacheMisses?: number;
   pathFilter?: string;
   matchingPathCount?: number;
   unknownPathCount?: number;
@@ -1640,6 +1816,7 @@ export interface FederatedUnfinishedRunLedgerQueryOptions {
   /** Pre-collected directories let callers separately observe target collection from ledger reads. */
   ledgerDirectories?: readonly string[];
   list?: (path: string) => string[];
+  noCache?: boolean;
   /**
    * When given, read only these run ledgers. Omitted means today's full scan of every
    * canonical *.jsonl plus the cross-directory unfinished-runId reconciliation.
@@ -1661,6 +1838,8 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   let indeterminateLedgerDirectoryCount = 0;
   let matchingPathCount = 0;
   let unknownPathCount = 0;
+  let cacheHits = 0;
+  let cacheMisses = 0;
   const recordDirectoryFailure = (kind: FederatedLedgerDirectoryFailureKind): void => {
     if (kind === 'missing') missingLedgerDirectoryCount += 1;
     else if (kind === 'unreadable') unreadableLedgerDirectoryAccessCount += 1;
@@ -1675,7 +1854,7 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
           const runId = runIdFromCanonicalLedgerFile(fileName);
           return runId !== null && requestedRunIds.has(runId);
         });
-      const result = queryUnfinishedRunLedgers({ dir: ledgerDirectory, goalsDir: goalsDirectory, ...(options.path === undefined ? {} : { path: options.path }), ...(list === undefined ? {} : { list }) });
+      const result = queryUnfinishedRunLedgers({ dir: ledgerDirectory, goalsDir: goalsDirectory, ...(options.path === undefined ? {} : { path: options.path }), ...(list === undefined ? {} : { list }), noCache: options.noCache });
       if (result.ledgerDirectoryMissing) {
         recordDirectoryFailure('missing');
         continue;
@@ -1684,6 +1863,8 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
       unreadableLedgerCount += result.unreadableLedgerCount;
       matchingPathCount += result.matchingPathCount ?? 0;
       unknownPathCount += result.unknownPathCount ?? 0;
+      cacheHits += result.cacheHits ?? 0;
+      cacheMisses += result.cacheMisses ?? 0;
       entries.push(...result.entries.map((entry) => ({ ...entry, ledgerDirectory })));
     } catch (error) {
       recordDirectoryFailure(classifyFederatedLedgerDirectoryReadFailure(error));
@@ -1700,9 +1881,9 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   const unfinishedRunIds = requestedRunIds === undefined ? new Set(entries.map((entry) => entry.runId)) : new Set([...requestedRunIds].filter((runId) => entries.some((entry) => entry.runId === runId)));
   for (const runId of unfinishedRunIds) {
     for (const ledgerDirectory of ledgerDirectories) {
-      let ledger: RunLedgerEntry[] | null = null;
-      try { ledger = loadRunLedger(runId, ledgerDirectory); } catch { ledger = null; }
-      if (ledger && hasTerminalRunStatus(ledger)) { terminatedElsewhere.add(runId); break; }
+      try {
+        if (readUnfinishedLedgerFacts(runId, ledgerDirectory, undefined, options.noCache).facts.terminal) { terminatedElsewhere.add(runId); break; }
+      } catch { /* An absent or unreadable sibling cannot establish termination. */ }
     }
   }
   const reconciledEntries = entries.filter((entry) => !terminatedElsewhere.has(entry.runId));
@@ -1720,6 +1901,8 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
     unreadableLedgerDirectoryAccessCount,
     indeterminateLedgerDirectoryCount,
     reconciledTerminatedElsewhereCount,
+    cacheHits,
+    cacheMisses,
     ...(options.path === undefined ? {} : { pathFilter: options.path, matchingPathCount, unknownPathCount }),
     scope: 'self-implement-run-ledger-federated',
     note: FEDERATED_UNFINISHED_RUN_LEDGER_NOTE,

package/src/self-implement/run-report.ts

@@ -0,0 +1,24 @@
+import type { SelfDevJobResult } from '../self-dev/orchestrate.js';
+
+/** One bounded final message for the originating chat; never includes the full goal text. */
+export function formatRunReport({ runId, results, failure }: {
+  runId: string;
+  results: readonly SelfDevJobResult[];
+  failure?: string;
+}): string {
+  const done = results.filter((result) => result.status === 'done').length;
+  const prs = results.filter((result) => result.prUrl).length;
+  const merged = results.filter((result) => result.merged).length;
+  const header = failure !== undefined
+    ? `⛔ 하니스 런 멈춤 — ${failure.split(/\r?\n/, 1)[0]!.slice(0, 200)}`
+    : `🏁 하니스 런 끝 — ${done}/${results.length} · PR ${prs} · 병합 ${merged}`;
+  const lines = results.slice(0, 8).map((result) => {
+    const icon = result.status === 'done' ? '✅' : result.status === 'cancelled' ? '⛔' : '❌';
+    const destination = result.merged && result.prUrl
+      ? ` → 병합 ${result.prUrl}`
+      : result.prUrl ? ` → PR ${result.prUrl}` : result.stage ? ` [${result.stage}]` : '';
+    return `${icon} ${result.feature.slice(0, 56)}${destination}${result.error ? ` — ${result.error.code}` : ''}`;
+  });
+  if (results.length > 8) lines.push(`외 ${results.length - 8}`);
+  return [header, ...lines, `${runId} · 자세히: elanous self screen --run ${runId}`].join('\n');
+}

package/src/self-implement/run-status-mapping.ts

@@ -12,6 +12,7 @@ export interface MappedRunOutcome {
 export type SelfImplementStage =
   | 'merged'
   | 'pr-opened'
+  | 'merge-ready'
   | 'worktree-completed'
   | 'gate-failed'
   | 'review-blocked'
@@ -24,6 +25,7 @@ export type SelfImplementStage =
 const STAGE_OUTCOMES = {
   merged: { runStatus: 'completed' },
   'pr-opened': { runStatus: 'completed' },
+  'merge-ready': { runStatus: 'completed' },
   'worktree-completed': { runStatus: 'completed' },
   'gate-failed': { runStatus: 'failed', failureKind: 'gate' },
   'review-blocked': { runStatus: 'failed', failureKind: 'review' },