elanous 0.2.13 → 0.2.15

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

@@ -0,0 +1,97 @@
+import { execFileSync } from 'node:child_process';
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+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, 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);
+  try {
+    const limit = Number.isSafeInteger(depth) && depth > 0 ? depth : 50;
+    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;
+        const current = readFileSync(join(cwd, file));
+        const rawOid = execFileSync('git', ['hash-object', '--stdin'], { cwd, input: current, timeout: 20_000 }).toString('utf8').trim();
+        const headEntry = git('ls-tree', 'HEAD', '--', file).toString('utf8').trim();
+        const head = /^\d+ blob ([0-9a-f]+)\t/.exec(headEntry)?.[1];
+        if (!head) continue;
+        const sameBytes = (oid: string): boolean => oid === rawOid || git('cat-file', 'blob', oid).equals(current);
+        if (sameBytes(head)) continue;
+        let matchedCommit: string | undefined;
+        const inspectedOids = new Set<string>();
+        for (const commit of commits.slice(1)) {
+          // A path may not have existed in an ancestor; that is not a failed inspection.
+          const blob = git('ls-tree', commit, '--', file).toString('utf8').trim();
+          const oid = /^\d+ blob ([0-9a-f]+)\t/.exec(blob)?.[1];
+          if (oid && !inspectedOids.has(oid)) {
+            if (sameBytes(oid)) { matchedCommit = commit; break; }
+            inspectedOids.add(oid);
+          }
+        }
+        if (!matchedCommit) continue;
+        if (isTargetPath(file, targets)) {
+          result.protected.push(file);
+          debug.log('self-implement.revert-guard', 'protected-target', { runId, files: [file], matchedCommit }, { level: 'warn' });
+        } else {
+          git('checkout', 'HEAD', '--', file);
+          result.reverted.push(file);
+          debug.log('self-implement.revert-guard', 'reverted-stale', { runId, files: [file], matchedCommit });
+        }
+      } 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' });
+      }
+    }
+  } catch (error) {
+    result.warning = `git inspection failed: ${reason(error)}`;
+    debug.log('self-implement.revert-guard', 'fail-open', { runId, reason: result.warning }, { level: 'warn' });
+  }
+  return result;
+}

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';
@@ -276,7 +277,7 @@ interface RunLedgerLookupTarget {
   targetName: string | null;
 }
 
-function resolveFederatedRunLedgerTargets(options: Pick<FederatedRunLedgerLookupOptions, 'includeTest' | 'targets'>): RunLedgerLookupTarget[] {
+export function resolveFederatedRunLedgerTargets(options: Pick<FederatedRunLedgerLookupOptions, 'includeTest' | 'targets'>): RunLedgerLookupTarget[] {
   const resolved = options.targets ? { targets: [...options.targets] } : resolveLogTargets({ all: true, includeTest: options.includeTest });
   if (resolved.error) throw new Error(resolved.error);
   const targets = new Map<string, string>();
@@ -402,6 +403,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

@@ -37,7 +37,8 @@ import { iosFilesIn, runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.
 import { detectGateCommand } from './detect-gate.js';
 import { writeScopedTypecheckConfig } from './scoped-typecheck-config.js';
 // ⭐ 게이트 스코프 근본 수리(2026-07-26) — 풀 `bun test` 폴백 제거 + 연관 테스트 유도(순수).
-import { resolveGateScope } from './gate-scope.js';
+import { formatNoRelatedTestsWarning, resolveGateScope } from './gate-scope.js';
+import { publicExposureFiles, runExposeGate } from './expose-gate.js';
 import { buildImporterTestIndex, isTestPath } from './importer-test-index.js';
 import { buildRouteConsumerTestIndex } from './route-consumer-test-index.js';
 import { countTestDeclarations } from './test-declarations.js';
@@ -976,6 +977,7 @@ export interface DefaultSeamsOptions {
   runIosUnitTestGate?: (io: { args: readonly string[]; cwd: string }) => number;
   /** Source-policy gate adapter for focused seam tests. */
   runHarnessPolicyGates?: typeof runHarnessPolicyGates;
+  runExposeGate?: typeof runExposeGate;
   /** Dependency-wide validation adapter for focused seam tests. */
   runDependencyChangeGate?: typeof runDependencyChangeGate;
   /** 워크트리 시험 묶음(없으면 실패 파일)을 base에서 재실행하는 seam. 실패 경로에서만 호출된다. */
@@ -1409,6 +1411,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       },
       removeMatchingGoalCopy,
     },
+    supersedeDraftsOnMerge: async (number, cwd) => {
+      const { supersedeMergedGoalDrafts } = await import('../harness/harness-cli-command.js');
+      await supersedeMergedGoalDrafts(number, cwd);
+    },
     lineageSupersede: {
       listOpenDrafts: () => listOpenDraftsForLineage(),
       readRunLedger: (runId) => {
@@ -1810,8 +1816,13 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       const observationChanges = gateChangedFiles(cwd, comparisonBase);
       const observationChangedFiles = observationChanges.files;
       const postsync = ctx?.mode === 'postsync';
-      // 정합 전 일반 게이트는 worktree-only. 정합 후 재게이트만 이미 계산된 merge-base 목록을 실행 범위로 쓴다.
-      const changedAll = postsync ? observationChangedFiles : gitChangedFiles(cwd);
+      // 일반 게이트는 기존 worktree 범위를 유지하되 fork 이후 커밋된 시험을 더한다.
+      // HEAD 대비 미커밋 목록만 쓰면 릴리스 노트만 남은 재작업 라운드에서
+      // 커밋된 시험을 놓쳐 docs-only 로 건너뛴다. postsync는 종전처럼 전 변경을 잰다.
+      const changedAll = postsync ? observationChangedFiles : [...new Set([
+        ...gitChangedFiles(cwd),
+        ...observationChangedFiles.filter((file) => isTestPath(file)),
+      ])];
       // ⚠️ **regular-file 판정**(리뷰 should-fix 5R) — `existsSync` 는 **디렉터리도 true** 다.
       //   계약은 "실존 테스트 **파일**"이므로 파일 여부까지 확인한다(디렉터리를 testArgs 로 넘기면
       //   필터 무매치 → "0 files ran" 부당 실패).
@@ -1824,11 +1835,19 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         trackedFiles.filter(isTestPath),
         [...new Set([...trackedFiles, ...changedAll, ...observationChangedFiles])].filter((file) => /\.(?:[cm]?[jt]sx?)$/.test(file)),
       );
-      const routeConsumerTestIndex = buildRouteConsumerTestIndex(cwd, trackedFiles.filter(isTestPath), changedAll, comparisonBase ?? 'HEAD');
+      // 런 전체 재탐색 시 앞 라운드의 변경·삭제 서버 경로도 비교-base 소비자 색인에 있어야 한다.
+      const routeConsumerTestIndex = buildRouteConsumerTestIndex(cwd, trackedFiles.filter(isTestPath),
+        [...new Set([...changedAll, ...observationChangedFiles])], comparisonBase ?? 'HEAD');
       // 워크트리에 없는 변경 경로 = 지운 파일 — 미검증으로 세지 않는다(gate-scope `isDeleted` · 2026-09-26 run-7dd4cce6).
       const isDeleted = (path: string): boolean => !isFile(path);
-      const scopeOpts = { isDeleted, routeConsumerTestIndex: routeConsumerTestIndex ?? undefined };
+      const scopeOpts = { isDeleted, routeConsumerTestIndex: routeConsumerTestIndex ?? undefined,
+        runChanged: observationChangedFiles, round: ctx?.round };
       const scope = resolveGateScope(changedAll, isFile, importerTestIndex ?? undefined, postsync ? { ...scopeOpts, mode: 'postsync' } : scopeOpts);
+      // The landing scope is the PR diff, not only this round's uncommitted test files.
+      const expose = publicExposureFiles(observationChangedFiles).length > 0
+        ? (o.runExposeGate ?? runExposeGate)(cwd, observationChangedFiles,
+          getUserConfig().harness?.exposeGate === 'strict' ? 'strict' : 'warn')
+        : { passed: true, log: '' };
       const comparisonFailureReason = observationChanges.comparisonBaseStatus === 'unavailable'
         ? 'comparison-base-unavailable'
         : observationChanges.comparisonBaseStatus === 'comparison-failed'
@@ -1865,6 +1884,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       debug.log('self-implement', 'gate.scope', {
         ...(ctx?.runId ? { runId: ctx.runId } : {}),
         targeted: gateOpts.testArgs?.length ?? 0, files: (gateOpts.testArgs ?? []).slice(0, 8),
+        'evaluated-changes': changedAll.slice(0, 8), evaluatedChangeCount: changedAll.length,
         changedTests: observedChangedTestFiles.slice(0, 8), changedTestCount: observedChangedTestFiles.length,
         srcChanged: scope.sourceFiles.length, testStepSkipped,
         scopeReason, derived: scope.derived.length, ignoredOutsideSrc: scope.ignoredOutsideSrc,
@@ -2053,7 +2073,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   `tc`(변경파일 tsc) **전에** 실행해서, tsc 가 깨져 **최종 게이트가 실패한 런에도**
       //   base 를 다시 돌리고 `gate.log` 를 바꿨다 ⇒ *"게이트 실패 경로 무변경"* 경계 위반.
       //   ⇒ 조건을 최종 판정과 같은 식으로 묶는다.
-      const gatePassed = !comparisonFailureReason && !unmeasuredPostsync && integrityPassed && tc.passed && policy.passed && (dependencyGate?.passed ?? true);
+      const gatePassed = !comparisonFailureReason && !unmeasuredPostsync && integrityPassed && tc.passed && policy.passed && expose.passed && (dependencyGate?.passed ?? true);
       const verifyIdentity = gateVerifyIdentity(ctx?.runId);
       if (gatePassed && scope.skipTestStep) {
         verifyByBreaking = { ran: false, distinguishes: 0, 'does-not-distinguish': 0, unknown: 0, skippedReason: scope.reason };
@@ -2204,7 +2224,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           + (scope.reason === 'no-related-tests'
             // ⭐ **미검증 파일 목록**(2026-07-27 사후 리뷰 수리) — 종전엔 `sourceFiles` 를 실어
             //   `package.json`·설정·스크립트 변경 시 **빈 목록**이 나갔다(그 파일들은 소스 확장자가 아니다).
-            ? `동작 검증을 못 한 변경: ${scope.unverified.slice(0, 8).join(', ')}`
+            ? `\n\n${formatNoRelatedTestsWarning(scope.unverified)}\n\n동작 검증을 못 한 변경: ${scope.unverified.slice(0, 8).join(', ')}`
               + `\n⚠️ 이 라운드는 **동작 검증이 되지 않았다**(변경파일 tsc 만 통과) — "게이트 통과=검증됨"으로 결론내지 말 것.`
               // ⚠️ 안내를 일반화(리뷰 should-fix) — `package.json`·lockfile·설정·스크립트에는
               //   "해당 소스의 테스트"라는 표현이 부정확하다(그 변경엔 대응 테스트 관례가 없다).
@@ -2229,7 +2249,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         : '';
       return {
         passed: gatePassed,
-        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}${callerOverflowNote}${routeLookupNote}`,
+        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}${callerOverflowNote}${routeLookupNote}${expose.log ? `\n\n${expose.log}` : ''}`,
         testStepExecuted: !testStepSkipped && testStep !== undefined && !testStep.skipped,
         scopeReason,
         comparisonBaseStatus: observationChanges.comparisonBaseStatus,
@@ -2493,7 +2513,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/index.ts

@@ -213,6 +213,8 @@ export interface SessionMeta {
   tgBotId?: string;
   /** Stable identity for a persona's resident conversation. */
   personaId?: string;
+  /** Optional persona selected for this conversation's replies (not resident identity). */
+  chatPersonaId?: string;
   /** Telegram session-key used for lookup by chat, e.g.
    *  `telegram:8799226199:dm:123:0` (bot-scoped) or legacy
    *  `telegram:dm:123:0`. Constructed once at create time. */