elanous 0.2.14 → 0.2.15

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';
@@ -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

@@ -2513,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/steward/triage.ts

@@ -260,9 +260,56 @@ function skipOverlappingRun(root: string, open: FailureStreak['open'] & { pid?:
   }
   debug.log('steward.stage', 'skipped-overlap', { openStage: open.stage, pid: open.pid });
   writeFileSync(skippedPath(root), JSON.stringify({ openStage: open.stage, pid: open.pid }));
+  logTickDecision(root, 'skipped', `overlapping ${open.stage} (pid ${open.pid ?? 'unknown'})`);
 }
 
 function reportPath(root: string): string { return join(root, 'steward', 'observe.json'); }
+
+type TickDecision = { verdict: 'launched' | 'failed'; reason: string; goalId?: string };
+
+function logTickDecision(root: string | undefined, verdict: 'launched' | 'skipped' | 'reported' | 'failed', reason: string, goalId?: string): void {
+  const runId = graphRunId();
+  const marker = root && runId && existsSync(join(root, 'steward')) ? join(root, 'steward', `decision-logged-${runId}.json`) : undefined;
+  const decision = { verdict, reason: redactSecretText(reason), ...(goalId ? { goalId } : {}), ...(runId ? { runId } : {}) };
+  if (marker) try {
+    const previous = JSON.parse(readFileSync(marker, 'utf8')) as { verdict?: string; reason?: string };
+    // A replay keeps the first success; a failure replaces a success; a success after a failure replaces the failure.
+    if (previous.verdict === decision.verdict && previous.reason === decision.reason) return;
+    if (previous.verdict !== 'failed' && verdict !== 'failed') return;
+  } catch { /* Missing or stale marker: retry the observation. */ }
+  try {
+    debug.log('loop.steward', 'decision', decision);
+    if (marker) writeFileSync(marker, JSON.stringify(decision));
+  } catch { /* Observation must not change the tick outcome. */ }
+}
+
+function tickDecisionPath(root: string, runId: string): string {
+  return join(root, 'steward', `decision-${runId}.json`);
+}
+function rememberLaunchDecision(root: string, entry: TickDecision): void {
+  const runId = graphRunId();
+  if (!runId) return;
+  const path = tickDecisionPath(root, runId);
+  try {
+    let current: TickDecision | undefined;
+    try { current = JSON.parse(readFileSync(path, 'utf8')) as TickDecision; }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return; }
+    // Keep the first failure (and its goal/cause), even if a retried schedule later succeeds.
+    if (current?.verdict === 'failed' || current?.verdict === entry.verdict) return;
+    writeFileSync(path, JSON.stringify(entry));
+  } catch { /* An unavailable observation store must not block execution. */ }
+}
+function readLaunchDecision(root: string): TickDecision | undefined {
+  const runId = graphRunId();
+  if (!runId) return undefined;
+  try { return JSON.parse(readFileSync(tickDecisionPath(root, runId), 'utf8')) as TickDecision; }
+  catch { return undefined; }
+}
+function logStageFailure(root: string, stage: StewardStage, reason: string): void {
+  const runId = graphRunId();
+  if (runId) try { rmSync(tickDecisionPath(root, runId), { force: true }); } catch { /* Observation must not change the failure. */ }
+  logTickDecision(root, 'failed', `${stage}: ${reason}`);
+}
 function readState(path: string): { issues: Record<string, string>; digestDay?: string } {
   try { return JSON.parse(readFileSync(path, 'utf8')) as ReturnType<typeof readState>; }
   catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { issues: {} }; throw error; }
@@ -396,10 +443,18 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const entry = raiseHitl(issue, row, launchDeps);
       recordHitlOnCard(issue, entry, cardDeps);
     }
+    let launchDecision: TickDecision | undefined;
     for (const item of plan.launches) {
       const entry = launch(item, launchDeps);
+      const decision: TickDecision | undefined = entry.status === 'launched'
+        ? { verdict: 'launched', reason: 'harness run spawned', goalId: `linear:${item.issue.identifier}` }
+        : entry.status === 'failed'
+          ? { verdict: 'failed', reason: entry.reason ?? 'launch failed', goalId: `linear:${item.issue.identifier}` }
+          : undefined;
+      if (decision && (!launchDecision || (decision.verdict === 'failed' && launchDecision.verdict !== 'failed'))) launchDecision = decision;
       recordLaunchOnCard(item.issue, entry, cardDeps);
     }
+    if (launchDecision) rememberLaunchDecision(root, launchDecision);
     if (settings.mode === 'shadow') {
       const { recordShadowTick } = await import('./readiness.js');
       const tick = recordShadowTick(root, rows, plan, (deps.now ?? (() => new Date()))());
@@ -459,12 +514,18 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       }
     }
     const day = at.slice(0, 10);
+    let digested = false;
     if (state.digestDay !== day) {
       const send = deps.sendDigest ?? sendStewardDigest;
       await send(`스튜어드 ${day}: ${rows.map(row => `${row.issue} ${row.disposition}`).join(' · ')}`);
       state.digestDay = day;
       writeFileSync(path, JSON.stringify(state));
+      digested = true;
     }
+    const launched = readLaunchDecision(root);
+    if (launched) logTickDecision(root, launched.verdict, launched.reason, launched.goalId);
+    else if (outcomes.length || digested) logTickDecision(root, 'reported', outcomes.length ? `${outcomes.length} outcome(s) reported` : 'daily digest sent');
+    else logTickDecision(root, 'skipped', 'no new outcome or digest');
   }
   outcome = 'ok';
   } finally {
@@ -513,10 +574,14 @@ async function withStageSlot<T>(root: string, run: () => Promise<T>, onBusy?: ()
 
 /** The command-node boundary records both normal exits and an unclosed stage from a killed process. */
 export async function runStewardStageCommand(stage: StewardStage, deps: StewardCommandDeps = {}): Promise<0 | 1> {
-  if (resolvedStewardSettings(deps.launchSettings).mode === 'off') return 0;
+  if (resolvedStewardSettings(deps.launchSettings).mode === 'off') {
+    if (stage === 'sync') logTickDecision(deps.root ?? effectiveInstanceRoot(), 'skipped', 'steward mode off');
+    return 0;
+  }
   const root = deps.root ?? effectiveInstanceRoot();
   if (stage !== 'sync' && existsSync(skippedPath(root))) return 0;
-  return withStageSlot(root, async () => {
+  try {
+    return await withStageSlot(root, async () => {
     const now = deps.now ?? (() => new Date());
     const threshold = stewardSettings().alertAfterFailures ?? 3;
     const alertIfNeeded = async (state: FailureStreak): Promise<void> => {
@@ -564,10 +629,16 @@ export async function runStewardStageCommand(stage: StewardStage, deps: StewardC
     if (!ok) {
       console.error(`steward ${stage}: stage failed — ${reason}`);
       debug.log('steward.stage', 'failed', { stage, reason });
+      if (stage === 'sync' || !existsSync(skippedPath(root))) logStageFailure(root, stage, reason);
       return 1;
     }
     return 0;
-  }, stage === 'sync' ? () => { skipOverlappingRun(root, currentOpen(root, stage)); return 0 as const; } : undefined);
+    }, stage === 'sync' ? () => { skipOverlappingRun(root, currentOpen(root, stage)); return 0 as const; } : undefined);
+  } catch (error) {
+    try { if (stage === 'sync' || !existsSync(skippedPath(root))) logStageFailure(root, stage, error instanceof Error ? error.message : String(error)); }
+    catch { /* Observation must not change the stage error. */ }
+    throw error;
+  }
 }
 
 export async function runStewardNodeCommand(

package/src/steward/working-backwards.ts

@@ -53,7 +53,10 @@ export async function recordWorkingBackwardsOnCards(
     }
     const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
     if (card.sections.some(section => section.key.startsWith('prfaq:')) && card.sections.some(section => section.key.startsWith('manual:'))) continue;
-    if (card.sections.some(section => section.key.startsWith('launch:'))) throw new Error(`Working-backwards draft follows launch: ${issue.identifier}`);
+    if (card.sections.some(section => section.key.startsWith('launch:'))) {
+      debug.log('steward.working-backwards', 'skipped-launched-before-draft', { issueId: issue.identifier });
+      continue;
+    }
     const draft = await draftWorkingBackwards(issue, ask);
     for (const [section, content] of [['prfaq', draft.prfaq], ['manual', draft.manual]] as const) {
       const key = `${section}:${createHash('sha256').update(content).digest('hex')}`;