elanous 0.2.14 → 0.2.16

package/src/self-implement/pipeline-shape.ts

@@ -16,7 +16,7 @@ export const TERMINAL_STAGES_BY_NODE = {
   implement: ['aborted', 'timed-out', 'soft-stopped', 'parked'],
   gate: [],
   review: ['review-blocked'],
-  rework: ['gate-failed', 'review-blocked'],
+  rework: ['gate-failed', 'review-blocked', 'no-changes'],
   'main-sync': ['merge-conflict'],
   regate: ['gate-failed'],
   'open-pr': ['pr-declined', 'pr-opened', 'worktree-completed'],

package/src/self-implement/revert-guard.ts

@@ -3,10 +3,17 @@ import { lstatSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 
-export type RevertGuardResult = { reverted: string[]; protected: string[]; warning?: string };
+export type RevertGuardResult = { reverted: string[]; protected: string[]; staleDeleted?: string[]; outsideDeleted?: string[]; warning?: string };
+
+function isTargetPath(file: string, targets: readonly string[]): boolean {
+  return targets.some((target) => {
+    const path = target.replace(/^\.\//, '').replace(/\/+$/, '');
+    return path !== '' && (file === path || file.startsWith(`${path}/`));
+  });
+}
 
 /** Compare the worktree's exact bytes with blobs from recent HEAD ancestry, before add -A. */
-export function dropStaleReverts(cwd: string, targets: readonly string[], runId: string, depth = 50): RevertGuardResult {
+export function dropStaleReverts(cwd: string, targets: readonly string[], runId: string, depth = 50, base?: string): RevertGuardResult {
   const result: RevertGuardResult = { reverted: [], protected: [] };
   const git = (...args: string[]): Buffer => execFileSync('git', args, { cwd, timeout: 20_000, maxBuffer: 16 * 1024 * 1024, stdio: ['pipe', 'pipe', 'pipe'] });
   const reason = (error: unknown): string => (error instanceof Error ? error.message : String(error)).replace(/\s+/g, ' ').slice(0, 240);
@@ -15,6 +22,38 @@ export function dropStaleReverts(cwd: string, targets: readonly string[], runId:
     const commits = git('rev-list', `--max-count=${limit + 1}`, 'HEAD').toString('utf8').trim().split('\n');
     const changed = git('diff', '--name-only', '--diff-filter=M', '-z', 'HEAD', '--').toString('utf8').split('\0').filter(Boolean);
     const staged = git('diff', '--cached', '--name-only', '--diff-filter=M', '-z', 'HEAD', '--').toString('utf8').split('\0').filter(Boolean);
+    const deleted = new Set([
+      ...git('diff', '--name-only', '--diff-filter=D', '-z', 'HEAD', '--').toString('utf8').split('\0').filter(Boolean),
+      ...git('diff', '--cached', '--name-only', '--diff-filter=D', '-z', 'HEAD', '--').toString('utf8').split('\0').filter(Boolean),
+    ]);
+    for (const file of deleted) {
+      if (isTargetPath(file, targets)) continue;
+      try {
+        // add -A stages the worktree: even a dangling symlink replaces the staged deletion.
+        try {
+          lstatSync(join(cwd, file));
+          continue;
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        }
+        // ls-tree returning an empty entry means absent; a failed lookup must not look like absence.
+        const headEntry = git('ls-tree', 'HEAD', '--', file).toString('utf8').trim();
+        if (!/^\d+ blob [0-9a-f]+\t/.test(headEntry)) continue;
+        const baseEntry = base ? git('ls-tree', base, '--', file).toString('utf8').trim() : null;
+        if (baseEntry === '' && base) {
+          git('checkout', 'HEAD', '--', file);
+          (result.staleDeleted ??= []).push(file);
+          result.reverted.push(file);
+          debug.log('self-implement.revert-guard', 'reverted-stale-delete', { runId, files: [file] });
+        } else {
+          (result.outsideDeleted ??= []).push(file);
+          debug.log('self-implement.revert-guard', 'outside-delete', { runId, files: [file] }, { level: 'warn' });
+        }
+      } catch (error) {
+        result.warning = `git inspection/checkout failed for ${file}: ${reason(error)}`;
+        debug.log('self-implement.revert-guard', 'fail-open', { runId, reason: result.warning }, { level: 'warn' });
+      }
+    }
     for (const file of new Set([...changed, ...staged])) {
       try {
         if (!lstatSync(join(cwd, file)).isFile()) continue;
@@ -37,11 +76,7 @@ export function dropStaleReverts(cwd: string, targets: readonly string[], runId:
           }
         }
         if (!matchedCommit) continue;
-        const scoped = targets.some((target) => {
-          const path = target.replace(/^\.\//, '').replace(/\/+$/, '');
-          return path !== '' && (file === path || file.startsWith(`${path}/`));
-        });
-        if (scoped) {
+        if (isTargetPath(file, targets)) {
           result.protected.push(file);
           debug.log('self-implement.revert-guard', 'protected-target', { runId, files: [file], matchedCommit }, { level: 'warn' });
         } else {

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

@@ -1,5 +1,6 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { refuseProductionLedgerWriteInTest } from '../harness/ledger-write-guard.js';
 import { tracedPathReferences, verbatimOriginalAsk } from './goal-author.js';
 import { parseAskTargetPathHintsResult } from '../self-dev/launch-preflight.js';
 import { isRunStatus } from './run-status-mapping.js';
@@ -93,6 +94,10 @@ export interface RunOriginData extends Record<string, unknown> {
   substrate: string;
   instance: string;
   elanousVersion: string;
+  /** install.json version. 못 읽으면 «unknown». */
+  installedVersion: string;
+  /** install.json commit. 못 읽으면 «unknown». */
+  installedCommit: string;
   podName?: string;
   nodeName?: string;
   podNamespace?: string;
@@ -402,6 +407,7 @@ 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 (refuseProductionLedgerWriteInTest(dir, 'run-ledger')) return;
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const live = runLedgerPath(entry.runId, dir);
   withRunLedgerLock(dir, entry.runId, () => {

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

@@ -16,6 +16,7 @@ export type SelfImplementStage =
   | 'worktree-completed'
   | 'gate-failed'
   | 'review-blocked'
+  | 'no-changes'
   | 'merge-conflict'
   | 'aborted'
   | 'timed-out'
@@ -30,6 +31,7 @@ const STAGE_OUTCOMES = {
   'worktree-completed': { runStatus: 'completed' },
   'gate-failed': { runStatus: 'failed', failureKind: 'gate' },
   'review-blocked': { runStatus: 'failed', failureKind: 'review' },
+  'no-changes': { runStatus: 'failed', failureKind: 'review' },
   'merge-conflict': { runStatus: 'failed', failureKind: 'merge-conflict' },
   aborted: { runStatus: 'failed', failureKind: 'aborted' },
   'timed-out': { runStatus: 'failed', failureKind: 'timed-out' },

package/src/self-implement/seams.ts

@@ -24,6 +24,9 @@ import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
 import { forkSessionById, HARNESS_SESSION_ORIGIN, isHarnessSessionOrigin } from '../session/index.js';
 import { configuredWorktreeRoot, getUserConfig, resolveRoleLlm } from '../user-config.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { addHarnessQueue } from '../harness/harness-queue.js';
+import { readFollowUpMode } from './follow-up-goals.js';
 import { getProviderForConfig } from '../llm.js';
 import { createWorktree, DEFAULT_BRANCH_WORKTREE_BASE, linkWorktreeDependencies, removeWorktree, resolveDefaultBranchBase, resolveMainRepoRoot } from '../git-fs/worktree.js';
 import { isWorktreeInUse, listActiveTerminalDirectories } from '../harness/harness-clean.js';
@@ -77,7 +80,8 @@ import { tscEnv, assessTypecheckExecution, classifyTypecheckErrors, diffTypechec
 import { nestCapReached, childNestEnv, nestInfo } from '../agent/nest-depth.js';
 import { harnessBoundaryEnv, harnessBoundaryRequestsEnv, harnessBoundaryResponsesEnv, harnessSpaceEnv, getHarnessSpace, normalizeSpaceId, getHarnessRunId, resolveRunIdentity } from '../harness/harness-space.js';
 import { debug } from '../debug/log.js';
-import { RELEASE_PATH_HOLD_MARKER, RELEASE_PATH_LABEL, releasePathHoldShouldPost, releasePathHoldCommentsArgs, releasePrFilePaths } from '../self-dev/release-path-guard.js';
+import { RELEASE_PATH_HOLD_MARKER, RELEASE_PATH_LABEL, releasePathHoldShouldPost, releasePathHoldCommentsArgs } from '../self-dev/release-path-guard.js';
+import { readPrFilesWithRateLimitFallback, runGhApp } from './app-api-budget.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { gateDecision, reviewDecision, mergeDecision } from './decision-events.js';
 import { LogStore } from '../mss/logging/log-store.js';
@@ -110,6 +114,10 @@ declare module './orchestrator.js' {
     /** PR close(+브랜치 삭제). 기본 구성은 PrManager.closePr 위임(같은 인자·같은 반환).
      *  오케스트레이터는 아직 부르지 않는다 — 그 배선은 조각 ②다. */
     closePr?: (prUrl: string, comment?: string) => boolean;
+    /** Find an issue comment on this PR by its body marker; absence is distinct from a failed lookup. */
+    findPrComment?: (opts: { number: number; marker: string; cwd: string; comments?: unknown }) => Promise<{ id: number; body: string } | undefined>;
+    /** Replace an existing PR issue comment by ID, using the same GitHub App identity as postPrComment. */
+    editPrComment?: (opts: { id: number; body: string; cwd: string }) => Promise<void>;
   }
 }
 import { harnessPolicyEnv } from './harness-policy.js';
@@ -1415,6 +1423,11 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       const { supersedeMergedGoalDrafts } = await import('../harness/harness-cli-command.js');
       await supersedeMergedGoalDrafts(number, cwd);
     },
+    followUp: {
+      mode: readFollowUpMode(),
+      stateRoot: elanousStateRoot(),
+      enqueue: (item) => addHarnessQueue({ seat: item.seat, say: item.say, idempotencyKey: item.idempotencyKey }),
+    },
     lineageSupersede: {
       listOpenDrafts: () => listOpenDraftsForLineage(),
       readRunLedger: (runId) => {
@@ -2394,46 +2407,62 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     postPrComment: async ({ number, body, cwd }) => {
       // Round comments go out as the GitHub App like the PR itself — a personal `gh` login made the owner a
       // participant and mailed them on merge (#22089).
-      if (body.startsWith(RELEASE_PATH_HOLD_MARKER)) {
+        if (body.startsWith(RELEASE_PATH_HOLD_MARKER)) {
         // Several merge surfaces may hold the same PR; post the release-path hold comment once.
         let history: unknown;
         try {
-          history = JSON.parse((await execFileAsync('gh', releasePathHoldCommentsArgs(number), {
+          history = JSON.parse((await runGhApp('post-pr-comment-history', releasePathHoldCommentsArgs(number), {
             cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
           })).stdout);
         } catch { history = undefined; }
         if (!releasePathHoldShouldPost(() => history)) return;
       }
-      await execFileAsync('gh', ['pr', 'comment', String(number), '--body', body], {
+      await runGhApp('post-pr-comment', ['pr', 'comment', String(number), '--body', body], {
+        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
+      });
+    },
+
+    findPrComment: async ({ number, marker, cwd, comments }) => {
+      const pages: unknown = comments ?? JSON.parse((await runGhApp('find-pr-comment', releasePathHoldCommentsArgs(number), {
+        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
+      })).stdout);
+      if (!Array.isArray(pages)) throw new Error('gh api PR comments returned an invalid list');
+      const entries = pages.flatMap((page: unknown) => Array.isArray(page) ? page : [page]);
+      for (const entry of entries) {
+        if (!entry || typeof entry !== 'object' || !('body' in entry) || typeof entry.body !== 'string'
+          || !('id' in entry) || typeof entry.id !== 'number' || !Number.isSafeInteger(entry.id) || entry.id <= 0) {
+          throw new Error('gh api PR comments returned an invalid comment');
+        }
+      }
+      return entries.find((entry: { id: number; body: string }) => entry.body.includes(marker));
+    },
+
+    editPrComment: async ({ id, body, cwd }) => {
+      await runGhApp('edit-pr-comment', ['api', '--method', 'PATCH', `repos/{owner}/{repo}/issues/comments/${id}`, '-f', `body=${body}`], {
         cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
       });
     },
 
     addPrLabel: async ({ number, label, cwd }) => {
       if (label === RELEASE_PATH_LABEL) {
-        const existing = await execFileAsync('gh', ['label', 'list', '--search', label, '--json', 'name'], {
+        const existing = await runGhApp('add-pr-label-list', ['label', 'list', '--search', label, '--json', 'name'], {
           cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
         });
         const names: unknown = JSON.parse(existing.stdout);
         if (!Array.isArray(names)) throw new Error('gh label list returned an invalid list');
         if (!names.some((item: unknown) => !!item && typeof item === 'object' && 'name' in item && item.name === label)) {
-          await execFileAsync('gh', ['label', 'create', label, '--color', 'D93F0B', '--description', 'Release path requires OP approval'], {
+          await runGhApp('add-pr-label-create', ['label', 'create', label, '--color', 'D93F0B', '--description', 'Release path requires OP approval'], {
             cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
           });
         }
       }
-      await execFileAsync('gh', ['pr', 'edit', String(number), '--add-label', label], {
+      await runGhApp('add-pr-label', ['pr', 'edit', String(number), '--add-label', label], {
         cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
       });
     },
-    readPrFiles: async ({ number, cwd }) => {
-      // Paginate the PR file API: a single `gh pr view --json files` can omit files after the first page.
-      const { stdout } = await execFileAsync('gh', [
-        'api', '--paginate', '--slurp', '--method', 'GET', '-f', 'per_page=100',
-        `repos/{owner}/{repo}/pulls/${number}/files`,
-      ], { cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env) });
-      return releasePrFilePaths(JSON.parse(stdout));
-    },
+    readPrFiles: async ({ number, cwd, base }) => readPrFilesWithRateLimitFallback({
+      number, cwd, env: ghAutomationEnv(process.env), ...(base ? { base } : {}),
+    }),
 
     ...(o.approvePr ? { approvePr: o.approvePr } : {}),
 
@@ -2513,7 +2542,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           verdict: rr.verdict,
           mustFix: rr.mustFix,
           shouldFix: rr.shouldFix,
-          summary: renderReview(rr).slice(0, 2000),
+          summary: rr.reviewed ? renderReview(rr).slice(0, 2000) : `리뷰 못 함(사유: ${rr.failureReason ?? '사유 미상'})`,
           reviewed: rr.reviewed ?? false,
           // ⛔⭐ 이 한 줄이 `orchestrator.ts` 의 「찍는 줄」에 값을 «흘린다». 빼면 그 줄은 살아 있는데 값이 안 온다.
           ...(rr.failureReason !== undefined ? { failureReason: rr.failureReason } : {}),

package/src/self-implement/self-implement-cli.ts

@@ -108,6 +108,7 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     stage: r.stage,
     ...(!r.ok && r.detail ? { error: { message: r.detail } } : {}),
     ...(r.branch ? { branch: r.branch } : {}),
+    ...(r.harvestable === true && r.branch ? { harvestable: true } : {}),
     ...(r.worktreePath ? { worktreePath: r.worktreePath } : {}),
     ...(r.prUrl ? { prUrl: r.prUrl } : {}),
     ...(r.merged !== undefined ? { merged: r.merged } : {}),

package/src/self-implement/speed-claims.ts

@@ -0,0 +1,338 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { seatOfTree } from '../loops/orchestrator/traffic.js';
+import { getUserConfig, ORCHESTRATOR_DEFAULTS } from '../user-config.js';
+import { isRunStatus } from './run-status-mapping.js';
+import { loadRunLedger, runLedgerDir, type RunLedgerEntry, type RunLedgerReader } from './run-ledger.js';
+
+export type SpeedClaimsOutcome = 'merged' | 'failed' | 'abandoned' | 'completed-without-merge';
+export type SpeedClaimsSeat = 'OP' | 'TC' | 'MK' | 'UX' | 'unknown';
+export interface SpeedClaimsRow {
+  seat: SpeedClaimsSeat;
+  outcome: SpeedClaimsOutcome;
+  count: number;
+  underOneMinuteCount: number;
+  medianMinutes: number;
+  q1Minutes: number;
+  q3Minutes: number;
+}
+export interface SpeedClaimsMeasurement {
+  scope: 'self-implement-run-ledger';
+  ledgerDirectory: string;
+  status: 'measured' | 'cannot-measure';
+  completedCount: number;
+  inProgressCount: number;
+  cannotMeasureCount: number;
+  unknownSeatCount: number;
+  rows: SpeedClaimsRow[];
+  note: string;
+  parent: ParentSpeedClaimsMeasurement;
+}
+export interface ParentSpeedClaimsEvent {
+  ts: string;
+  category: string;
+  event: string;
+  data: unknown;
+}
+
+export interface ParentSpeedClaimsRow {
+  seat: 'OP' | 'TC' | 'MK' | 'UX' | 'direct' | 'unknown';
+  stage: string;
+  merged: boolean;
+  count: number;
+  medianMinutes: number;
+  q1Minutes: number;
+  q3Minutes: number;
+}
+
+export interface ParentSpeedClaimsMeasurement {
+  scope: 'self-dev.orchestrate-parent-logs';
+  status: 'measured' | 'cannot-measure';
+  completedCount: number;
+  inProgressCount: number;
+  cannotMeasureCount: number;
+  rows: ParentSpeedClaimsRow[];
+  note: string;
+}
+
+export interface SpeedClaimsOptions {
+  dir?: string;
+  list?: (path: string) => string[];
+  read?: RunLedgerReader;
+  readSeat?: (runId: string, ledgerDirectory: string, entries: readonly RunLedgerEntry[]) => SpeedClaimsSeat;
+  readParentEvents?: () => readonly ParentSpeedClaimsEvent[];
+  readParentQueue?: () => unknown;
+}
+
+const NOTE = 'Child-ledger elapsed minutes from the first child event (or checkpoint creation when unavailable) to the recorded child end, including retries and resumes; this is not the parent launch-to-done interval. Only finished runs enter quartiles (linear interpolation at ranks (n-1)*p). In-progress runs (including parked) and missing, unreadable or invalid timestamps are excluded, not assigned zero. Seats come from the same state root checkpoint, launch queue or recorded launch tree; unresolved seats are counted separately. A completed run without a recorded merge is not a merge.';
+const CANONICAL_RUN_ID = /^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const SEATS: readonly SpeedClaimsSeat[] = ['OP', 'TC', 'MK', 'UX', 'unknown'];
+
+function checkpointFor(runId: string, ledgerDirectory: string): Record<string, unknown> | null {
+  try {
+    const value: unknown = JSON.parse(readFileSync(join(dirname(ledgerDirectory), 'self-dev-runs', `${runId}.json`), 'utf8'));
+    return value && typeof value === 'object' && !Array.isArray(value) && 'runId' in value && value.runId === runId
+      ? value as Record<string, unknown> : null;
+  } catch { return null; }
+}
+
+function seatFromLaunch(runId: string, ledgerDirectory: string, entries: readonly RunLedgerEntry[]): SpeedClaimsSeat {
+  const checkpoint = checkpointFor(runId, ledgerDirectory);
+  if (SEATS.includes(checkpoint?.seat as SpeedClaimsSeat) && checkpoint?.seat !== 'unknown') return checkpoint!.seat as SpeedClaimsSeat;
+  // Queue ids and launch ids are not run ids. Only an exact, unique ask-file match can attribute a queued launch.
+  const goalFiles = new Set(entries.filter((entry) => entry.event === 'start')
+    .map((entry) => entry.data.goalFile).filter((file): file is string => typeof file === 'string' && isAbsolute(file)));
+  if (goalFiles.size === 1) {
+    try {
+      const queue: unknown = JSON.parse(readFileSync(join(dirname(ledgerDirectory), 'harness', 'queue.json'), 'utf8'));
+      if (Array.isArray(queue)) {
+        const matched = queue.filter((row) => row && typeof row === 'object' && row.kind === 'ask'
+          && (row.status === 'launching' || row.status === 'launched' || row.status === 'finished')
+          && row.input === [...goalFiles][0] && SEATS.includes(row.seat));
+        if (matched.length === 1 && matched[0]!.seat !== 'unknown') return matched[0]!.seat as SpeedClaimsSeat;
+      }
+    } catch { /* An absent or unreadable queue cannot establish attribution. */ }
+  }
+  try {
+    const cfg = getUserConfig().loops?.orchestrator ?? ORCHESTRATOR_DEFAULTS;
+    const paths = entries.flatMap((entry) => entry.event === 'start' ? [entry.data.targetRoot] : entry.event === 'worktree' ? [entry.data.path] : []);
+    const seats = new Set<SpeedClaimsSeat>();
+    for (const path of paths) {
+      if (typeof path !== 'string' || !isAbsolute(path)) continue;
+      try {
+        const seat = seatOfTree(path, cfg);
+        if (seat) seats.add(seat);
+      } catch { /* A removed or unreadable launch tree does not prove a seat. */ }
+    }
+    if (seats.size === 1) return [...seats][0]!;
+  } catch { /* Unavailable seat configuration does not erase a readable run. */ }
+  return 'unknown';
+}
+
+function parseTime(timestamp: unknown): number | null {
+  if (typeof timestamp !== 'string') return null;
+  const match = /^(\d{4})-(\d\d)-(\d\d)T\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.exec(timestamp);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const days = [31, year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (month < 1 || month > 12 || day < 1 || day > days[month - 1]!) return null;
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function time(entry: RunLedgerEntry | undefined): number | null {
+  return parseTime(entry?.timestamp);
+}
+
+function percentile(sorted: readonly number[], p: number): number {
+  const rank = (sorted.length - 1) * p;
+  const low = Math.floor(rank);
+  return sorted[low]! + (sorted[Math.ceil(rank)]! - sorted[low]!) * (rank - low);
+}
+
+function endOfRun(entries: readonly RunLedgerEntry[]): { entry: RunLedgerEntry; outcome: SpeedClaimsOutcome } | null {
+  let end: { entry: RunLedgerEntry; outcome: SpeedClaimsOutcome } | null = null;
+  for (const entry of entries) {
+    if (entry.event === 'start') { end = null; continue; }
+    if (entry.event === 'merged' && entry.data.merged === true) end = { entry, outcome: 'merged' };
+    if (end?.outcome === 'merged') continue;
+    if (entry.event === 'human-stop') end = { entry, outcome: 'abandoned' };
+    if (entry.event === 'run-status' && isRunStatus(entry.data.runStatus)) {
+      const status = entry.data.runStatus;
+      if (status === 'completed') end = { entry, outcome: 'completed-without-merge' };
+      else if (status === 'failed') end = { entry, outcome: entry.data.stage === 'aborted' ? 'abandoned' : 'failed' };
+      else if (status === 'cancelled') end = { entry, outcome: 'abandoned' };
+      else end = null;
+    }
+  }
+  return end;
+}
+
+const PARENT_NOTE = 'Elapsed minutes from the earliest valid parent self-dev.orchestrate start log to the latest valid done log, grouped by that done.data.outcomes[].stage and merged flag. Only runs with both events and valid timestamps enter quartiles. A start without done is in progress. Seats use the same-runId queue seat when available, or direct when a readable queue has no matching entry; an unreadable queue remains unknown. Parent log queries are read-only and independent of child run ledgers.';
+type ParentSeat = ParentSpeedClaimsRow['seat'];
+const PARENT_SEATS: readonly ParentSeat[] = ['OP', 'TC', 'MK', 'UX', 'direct', 'unknown'];
+
+function object(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+
+/** Read the first-class logs CLI rather than opening logs.db in the measurement process. */
+function readParentEventsFromLogs(): ParentSpeedClaimsEvent[] {
+  const command = fileURLToPath(new URL('../../bin/elanous.mjs', import.meta.url));
+  const events: ParentSpeedClaimsEvent[] = [];
+  let before: string | undefined;
+  const seenCursors = new Set<string>();
+  for (;;) {
+    const result = spawnSync(process.execPath, [command, `--test=${fileURLToPath(new URL('../../', import.meta.url))}`, 'logs', '--instance', 'prod', '--category', 'self-dev.orchestrate', '--json', '--json-data', '--limit', '5000', ...(before ? ['--before', before] : [])], {
+      encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
+    });
+    if (result.error || result.status !== 0) throw new Error(result.stderr || result.error?.message || 'parent logs query failed');
+    const lines = result.stdout.trim().split('\n').filter(Boolean).map((line) => JSON.parse(line) as Record<string, unknown>);
+    if (lines.some((line) => object(line._meta)?.type === 'log-query-unreadable-instances')) throw new Error('parent logs query incomplete');
+    events.push(...lines.filter((line): line is Record<string, unknown> & ParentSpeedClaimsEvent =>
+      line.store === 'prod' && line.category === 'self-dev.orchestrate' && typeof line.ts === 'string' && typeof line.event === 'string'));
+    const limit = lines.find((line) => object(line._meta)?.type === 'log-query-limit');
+    if (!limit) return events;
+    const meta = object(limit._meta);
+    const cursor = meta?.nextCursors ?? meta?.nextCursor;
+    if (typeof cursor !== 'number' && !object(cursor)) throw new Error('parent logs pagination incomplete');
+    const next = typeof cursor === 'number' ? String(cursor) : JSON.stringify(cursor);
+    if (seenCursors.has(next)) throw new Error('parent logs pagination repeated a cursor');
+    seenCursors.add(next);
+    before = next;
+  }
+}
+
+function readParentQueueFromState(): unknown {
+  return JSON.parse(readFileSync(join(prodInstanceRoot(), 'harness', 'queue.json'), 'utf8')) as unknown;
+}
+
+/** Parent launch-to-done census; no child ledger id is used as a join key. */
+export function measureParentSpeedClaims(
+  events: readonly ParentSpeedClaimsEvent[], queue?: unknown,
+): ParentSpeedClaimsMeasurement {
+  const result: ParentSpeedClaimsMeasurement = {
+    scope: 'self-dev.orchestrate-parent-logs', status: 'measured', completedCount: 0,
+    inProgressCount: 0, cannotMeasureCount: 0, rows: [], note: PARENT_NOTE,
+  };
+  const queueRows = Array.isArray(queue) ? queue : object(queue)?.items;
+  const queueByRun = new Map<string, ParentSeat | null>();
+  if (Array.isArray(queueRows)) for (const raw of queueRows) {
+    const entry = object(raw);
+    if (entry && typeof entry.runId === 'string' && PARENT_SEATS.includes(entry.seat as ParentSeat) && entry.seat !== 'direct') {
+      const seat = entry.seat as ParentSeat;
+      queueByRun.set(entry.runId, queueByRun.has(entry.runId) && queueByRun.get(entry.runId) !== seat ? null : seat);
+    }
+  }
+  const runs = new Map<string, { start?: number; end?: number; outcomes?: unknown }>();
+  for (const event of events) {
+    if (event.category !== 'self-dev.orchestrate' || (event.event !== 'start' && event.event !== 'done')) continue;
+    const data = object(event.data);
+    const runId = data?.runId;
+    if (typeof runId !== 'string' || !CANONICAL_RUN_ID.test(runId)) { result.cannotMeasureCount++; continue; }
+    const run = runs.get(runId) ?? {};
+    const at = parseTime(event.ts);
+    if (event.event === 'start') {
+      if (at !== null) run.start = run.start === undefined || !Number.isFinite(run.start) ? at : Math.min(run.start, at);
+      else if (run.start === undefined) run.start = NaN;
+    } else if (at !== null && (run.end === undefined || !Number.isFinite(run.end) || at > run.end)) {
+      run.end = at;
+      run.outcomes = data?.outcomes;
+    } else if (at === null && run.end === undefined) {
+      run.end = NaN;
+    }
+    runs.set(runId, run);
+  }
+  const groups = new Map<string, { seat: ParentSeat; stage: string; merged: boolean; values: number[] }>();
+  for (const [runId, run] of runs) {
+    if (run.start === undefined && run.end !== undefined) { result.cannotMeasureCount++; continue; }
+    if (run.end === undefined) { result.inProgressCount++; continue; }
+    if (run.start === undefined || !Number.isFinite(run.start) || !Number.isFinite(run.end) || run.end < run.start || !Array.isArray(run.outcomes) || run.outcomes.length === 0) {
+      result.cannotMeasureCount++;
+      continue;
+    }
+    const seat = queueByRun.has(runId) ? (queueByRun.get(runId) ?? 'unknown') : Array.isArray(queueRows) ? 'direct' : 'unknown';
+    const outcomes = run.outcomes.map(object);
+    if (outcomes.some((outcome) => !outcome)) {
+      result.cannotMeasureCount++;
+      continue;
+    }
+    for (const outcome of outcomes) {
+      const stage = typeof outcome!.stage === 'string' ? outcome!.stage : 'unknown';
+      const merged = outcome!.merged === true;
+      const key = JSON.stringify([seat, stage, merged]);
+      const group = groups.get(key) ?? { seat, stage, merged, values: [] };
+      group.values.push((run.end - run.start!) / 60_000);
+      groups.set(key, group);
+    }
+    result.completedCount++;
+  }
+  result.rows = [...groups.values()].map(({ seat, stage, merged, values }) => {
+    values.sort((a, b) => a - b);
+    return { seat, stage, merged, count: values.length, medianMinutes: percentile(values, 0.5), q1Minutes: percentile(values, 0.25), q3Minutes: percentile(values, 0.75) };
+  }).sort((a, b) => PARENT_SEATS.indexOf(a.seat) - PARENT_SEATS.indexOf(b.seat) || a.stage.localeCompare(b.stage));
+  if (result.cannotMeasureCount > 0) result.status = 'cannot-measure';
+  return result;
+}
+
+/** Read-only elapsed-time census of canonical local run ledgers, including unsuccessful runs. */
+export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaimsMeasurement {
+  const ledgerDirectory = resolve(options.dir ?? runLedgerDir());
+  let parent: ParentSpeedClaimsMeasurement;
+  try {
+    const events = (options.readParentEvents ?? readParentEventsFromLogs)();
+    let queue: unknown;
+    try { queue = (options.readParentQueue ?? readParentQueueFromState)(); } catch { /* Queue absence does not erase parent observations or establish a direct launch. */ }
+    parent = measureParentSpeedClaims(events, queue);
+  } catch {
+    parent = { ...measureParentSpeedClaims([]), status: 'cannot-measure' };
+  }
+  const result: SpeedClaimsMeasurement = {
+    scope: 'self-implement-run-ledger', ledgerDirectory, status: 'measured',
+    completedCount: 0, inProgressCount: 0, cannotMeasureCount: 0, unknownSeatCount: 0, rows: [], note: NOTE, parent,
+  };
+  let files: string[];
+  try { files = (options.list ?? readdirSync)(ledgerDirectory); }
+  catch { return { ...result, status: 'cannot-measure' }; }
+
+  const groups = new Map<string, { seat: SpeedClaimsSeat; outcome: SpeedClaimsOutcome; values: number[] }>();
+  for (const file of files.sort()) {
+    const runId = file.endsWith('.jsonl') ? file.slice(0, -'.jsonl'.length) : '';
+    if (!CANONICAL_RUN_ID.test(runId)) continue;
+    try {
+      const entries = loadRunLedger(runId, ledgerDirectory, options.read);
+      if (!entries || entries.length === 0) { result.cannotMeasureCount++; continue; }
+      const end = endOfRun(entries);
+      const first = time(entries[0]);
+      const createdAt = checkpointFor(runId, ledgerDirectory)?.createdAt;
+      const creation = typeof createdAt === 'number' && Number.isFinite(createdAt) && createdAt >= 0 ? createdAt : null;
+      const start = first === null ? creation : first;
+      const endTime = end ? time(end.entry) : null;
+      if (start === null || (end && (endTime === null || endTime < start))) {
+        result.cannotMeasureCount++;
+        continue;
+      }
+      if (!end) { result.inProgressCount++; continue; }
+      const seat = (options.readSeat ?? seatFromLaunch)(runId, ledgerDirectory, entries);
+      const safeSeat = SEATS.includes(seat) ? seat : 'unknown';
+      if (safeSeat === 'unknown') result.unknownSeatCount++;
+      const key = `${safeSeat}:${end.outcome}`;
+      const group = groups.get(key) ?? { seat: safeSeat, outcome: end.outcome, values: [] };
+      group.values.push((endTime! - start) / 60_000);
+      groups.set(key, group);
+      result.completedCount++;
+    } catch { result.cannotMeasureCount++; }
+  }
+  result.rows = [...groups.values()].map(({ seat, outcome, values }) => {
+    values.sort((a, b) => a - b);
+    return { seat, outcome, count: values.length, underOneMinuteCount: values.filter((minutes) => minutes < 1).length, medianMinutes: percentile(values, 0.5), q1Minutes: percentile(values, 0.25), q3Minutes: percentile(values, 0.75) };
+  }).sort((a, b) => SEATS.indexOf(a.seat) - SEATS.indexOf(b.seat) || a.outcome.localeCompare(b.outcome));
+  if (result.cannotMeasureCount > 0) result.status = 'cannot-measure';
+  return result;
+}
+
+export function renderSpeedClaims(result: SpeedClaimsMeasurement): string {
+  return [
+    'child run-ledger (child start → child end):',
+    `ledger directory: ${result.ledgerDirectory}`,
+    `status: ${result.status}`,
+    `finished (quartile denominator): ${result.completedCount}`,
+    `in progress (excluded): ${result.inProgressCount}`,
+    `cannot measure (excluded): ${result.cannotMeasureCount}`,
+    `unknown seat (finished): ${result.unknownSeatCount}`,
+    ...result.rows.map((row) => `seat=${row.seat} outcome=${row.outcome} count=${row.count} underOneMinute=${row.underOneMinuteCount} median=${row.medianMinutes}m q1=${row.q1Minutes}m q3=${row.q3Minutes}m`),
+    `note: ${result.note}`,
+    'parent launch → done (self-dev.orchestrate):',
+    `parent status: ${result.parent.status}`,
+    `parent finished (quartile denominator): ${result.parent.completedCount}`,
+    `parent in progress (excluded): ${result.parent.inProgressCount}`,
+    `parent cannot measure (excluded): ${result.parent.cannotMeasureCount}`,
+    ...result.parent.rows.map((row) => `seat=${row.seat} stage=${row.stage} merged=${row.merged} count=${row.count} median=${row.medianMinutes}m q1=${row.q1Minutes}m q3=${row.q3Minutes}m`),
+    `parent note: ${result.parent.note}`,
+  ].join('\n');
+}

package/src/session-runtime/index.ts

@@ -66,6 +66,8 @@ export {
 export {
   fetchApiWithRetry,
   ApiHttpError,
+  OverloadFailoverError,
+  recordLlmCallOutcome,
   type FetchApiWithRetryOpts,
 } from './retry-api.js';