elanous 0.2.22 → 0.2.23

package/src/self-implement/follow-up-goals.ts

@@ -1,6 +1,6 @@
-// FOLLOWUP-LOOP① — after a harness PR merges, leftover findings become one
-// follow-up goal draft. Default mode is shadow: record only. `live` also
-// enqueues through the same function as `harness queue add`.
+// FOLLOWUP-LOOP① — leftover findings after a merge or blocked run become
+// follow-up drafts. Default mode is shadow; only merged drafts in `live` mode
+// enqueue through the same function as `harness queue add`.
 //
 // The test process injects every store. Nothing here opens the operational
 // ledger or queue unless the caller passes those seams.
@@ -25,6 +25,9 @@ export type FollowUpMode = 'shadow' | 'live';
 
 export interface FollowUpDraftRecord {
   prNumber: number;
+  ending?: 'blocked';
+  runId?: string;
+  stage?: 'review-blocked' | 'gate-failed';
   cellId: string;
   depth: number;
   draftHash: string;
@@ -54,6 +57,17 @@ export interface FollowUpMergeInput {
   goalFile?: string;
 }
 
+export interface FollowUpBlockedInput {
+  runId: string;
+  prNumber?: number;
+  stage: 'review-blocked' | 'gate-failed';
+  unresolvedMustFix?: readonly string[];
+  decompositionPieces?: readonly string[];
+  feature: string;
+  cellId?: string;
+  goalFile?: string;
+}
+
 export interface FollowUpSeams {
   stateRoot?: string;
   mode?: FollowUpMode;
@@ -144,10 +158,15 @@ export function followUpDraftHash(text: string): string {
   return createHash('sha256').update(text).digest('hex').slice(0, 16);
 }
 
+/** Legacy merge rows have no ending; blocked rows use run identity even without a PR. */
+function followUpRecordKey(record: Pick<FollowUpDraftRecord, 'prNumber' | 'ending' | 'runId'>): string {
+  return record.ending === 'blocked' ? `run:${record.runId}` : `pr:${record.prNumber}`;
+}
+
 /** Chain length of follow-up goals already recorded for this cell, before this one. */
-export function followUpChainDepth(prior: readonly Pick<FollowUpDraftRecord, 'kind' | 'prNumber'>[]): number {
-  // 한 PR 이 «기록 → 대기열 확정» 두 줄을 남길 수 있으니 PR 번호로 센다.
-  return new Set(prior.filter((record) => record.kind === 'draft' || record.kind === 'op-card-required').map((record) => record.prNumber)).size;
+export function followUpChainDepth(prior: readonly Pick<FollowUpDraftRecord, 'kind' | 'prNumber' | 'ending' | 'runId'>[]): number {
+  // 기록 → 대기열 확정 두 줄은 하나로 세되, PR 없는 서로 다른 런은 분리한다.
+  return new Set(prior.filter((record) => record.kind === 'draft' || record.kind === 'op-card-required').map(followUpRecordKey)).size;
 }
 
 /** Seat = the cell's owner. `TC/rel` keeps the seat `TC`. Unknown or absent owners go to OP (ONEDOOR). */
@@ -175,13 +194,23 @@ function defaultReadDrafts(stateRoot: string, cellId: string): FollowUpDraftReco
   return out;
 }
 
-/** 같은 PR 은 칸과 무관하게 한 번 — 칸 id 가 달리 들어와도 다시 만들지 않는다. */
-function defaultPrRecorded(stateRoot: string, prNumber: number): boolean {
+/** 같은 PR 또는 같은 blocked 런은 칸과 무관하게 한 번 기록한다. */
+function defaultRecordExists(stateRoot: string, key: string): boolean {
   let text = '';
   try { text = readFileSync(followUpDraftsPath(stateRoot), 'utf8'); } catch { return false; }
   return text.split('\n').some((line) => {
     if (!line.trim()) return false;
-    try { return (JSON.parse(line) as FollowUpDraftRecord).prNumber === prNumber; } catch { return false; }
+    try { return followUpRecordKey(JSON.parse(line) as FollowUpDraftRecord) === key; } catch { return false; }
+  });
+}
+
+function defaultAppendFirst(stateRoot: string, record: FollowUpDraftRecord): boolean {
+  const path = followUpDraftsPath(stateRoot);
+  mkdirSync(dirname(path), { recursive: true });
+  return withFileLockSync(`${path}.lock`, () => {
+    if (defaultRecordExists(stateRoot, followUpRecordKey(record))) return false;
+    defaultAppendDraft(stateRoot, record);
+    return true;
   });
 }
 
@@ -209,7 +238,10 @@ export async function recordFollowUpOnMerge(input: FollowUpMergeInput, seams: Fo
   const log = seams.log ?? ((category, event, data) => { debug.log(category, event, data); });
   try {
     const remainings = collectRemainings(input);
-    if (remainings.length === 0) return null;
+    if (remainings.length === 0) {
+      log('self-implement.follow-up', 'draft-skipped-empty', { ending: 'merged', prNumber: input.prNumber });
+      return null;
+    }
     // No injected store and no explicit state root: this is the test process.
     // Do not open the operational ledger or the harness queue.
     // A test process handed the operational root (defaultSeams) is refused the same way.
@@ -222,8 +254,9 @@ export async function recordFollowUpOnMerge(input: FollowUpMergeInput, seams: Fo
       return null;
     }
     const prior = (seams.readDrafts ?? ((id) => defaultReadDrafts(stateRoot, id)))(cellId);
-    if (prior.some((record) => record.prNumber === input.prNumber)) return null;
-    if (!seams.readDrafts && defaultPrRecorded(stateRoot, input.prNumber)) return null;
+    const key = followUpRecordKey({ prNumber: input.prNumber });
+    if (prior.some((record) => followUpRecordKey(record) === key)) return null;
+    if (!seams.readDrafts && defaultRecordExists(stateRoot, key)) return null;
     const depth = followUpChainDepth(prior) + 1;
     const firstLine = originalAskFirstLine(input.feature);
     const mode = seams.mode ?? readFollowUpMode();
@@ -245,39 +278,37 @@ export async function recordFollowUpOnMerge(input: FollowUpMergeInput, seams: Fo
     const append = seams.appendDraft ?? ((row: FollowUpDraftRecord) => defaultAppendDraft(stateRoot, row));
     const appendFirst = seams.appendDraft
       ? (row: FollowUpDraftRecord) => { append(row); return true; }
-      : (row: FollowUpDraftRecord) => (mkdirSync(dirname(followUpDraftsPath(stateRoot)), { recursive: true }), withFileLockSync(`${followUpDraftsPath(stateRoot)}.lock`, () => {
-        if (defaultPrRecorded(stateRoot, row.prNumber)) return false;
-        defaultAppendDraft(stateRoot, row);
-        return true;
-      }));
+      : (row: FollowUpDraftRecord) => defaultAppendFirst(stateRoot, row);
     if (!overDepth && mode === 'live' && draft) record.seat = seatForCellOwner((seams.cellOwner ?? defaultCellOwner)(cellId));
     // 원장 기록을 먼저 확정한다 — 기록이 실패하면 대기열에 넣지 않는다(같은 PR 한 번 · 원장 밖 연결골 0).
     if (!appendFirst(record)) return null;
     if (!overDepth && mode === 'live' && draft && record.seat) {
       const seat = record.seat;
-      if (testProcess && !seams.enqueue) return record;
-      try {
-        await (seams.enqueue ?? ((item) => addHarnessQueue({ seat: item.seat, say: item.say, idempotencyKey: item.idempotencyKey })))({
-          seat,
-          say: draft,
-          idempotencyKey: `follow-up:${input.prNumber}`,
-        });
-        record.queued = true;
-      } catch (error) {
-        // 대기열 넣기가 실패해도 초안은 남긴다 — 같은 PR 은 다시 오지 않으므로 여기서 잃으면 영영 없다.
-        // queued=false ⊕ enqueueError 로 원장에 남기고, 재투입은 같은 idempotencyKey 로 사람이·다음 수리 노드가 한다.
-        record.enqueueError = (error instanceof Error ? error.message : String(error)).slice(0, 300);
-        log('self-implement.follow-up', 'enqueue-failed', { prNumber: input.prNumber, seat, error: record.enqueueError });
-      }
-      // 대기열 결과를 원장에 한 줄 더 — 이 쓰기의 실패는 대기열 실패와 다른 사건이다.
-      try {
-        append({ ...record });
-      } catch (error) {
-        log('self-implement.follow-up', 'ledger-confirm-failed', {
-          prNumber: input.prNumber, seat, queued: record.queued, error: error instanceof Error ? error.message : String(error),
-        });
+      if (!(testProcess && !seams.enqueue)) {
+        try {
+          await (seams.enqueue ?? ((item) => addHarnessQueue({ seat: item.seat, say: item.say, idempotencyKey: item.idempotencyKey })))({
+            seat,
+            say: draft,
+            idempotencyKey: `follow-up:${input.prNumber}`,
+          });
+          record.queued = true;
+        } catch (error) {
+          // 대기열 넣기가 실패해도 초안은 남긴다 — 같은 PR 은 다시 오지 않으므로 여기서 잃으면 영영 없다.
+          // queued=false ⊕ enqueueError 로 원장에 남기고, 재투입은 같은 idempotencyKey 로 사람이·다음 수리 노드가 한다.
+          record.enqueueError = (error instanceof Error ? error.message : String(error)).slice(0, 300);
+          log('self-implement.follow-up', 'enqueue-failed', { prNumber: input.prNumber, seat, error: record.enqueueError });
+        }
+        // 대기열 결과를 원장에 한 줄 더 — 이 쓰기의 실패는 대기열 실패와 다른 사건이다.
+        try {
+          append({ ...record });
+        } catch (error) {
+          log('self-implement.follow-up', 'ledger-confirm-failed', {
+            prNumber: input.prNumber, seat, queued: record.queued, error: error instanceof Error ? error.message : String(error),
+          });
+        }
       }
     }
+    log('self-implement.follow-up', 'drafted', { ending: 'merged', prNumber: input.prNumber, cellId, depth, kind: record.kind, mode, queued: record.queued, remainingCount: remainings.length });
     return record;
   } catch (error) {
     log('self-implement.follow-up', 'draft-failed', {
@@ -287,3 +318,48 @@ export async function recordFollowUpOnMerge(input: FollowUpMergeInput, seams: Fo
     return null;
   }
 }
+
+/** Blocked runs leave a draft in the ledger only, even when follow-up mode is live. */
+export async function recordFollowUpOnBlocked(input: FollowUpBlockedInput, seams: FollowUpSeams = {}): Promise<FollowUpDraftRecord | null> {
+  const log = seams.log ?? ((category, event, data) => { debug.log(category, event, data); });
+  const prNumber = input.prNumber ?? 0;
+  try {
+    const remainings = collectRemainings({ followUpMustFix: input.unresolvedMustFix, shouldFix: input.decompositionPieces });
+    if (remainings.length === 0) {
+      log('self-implement.follow-up', 'draft-skipped-empty', { ending: 'blocked', prNumber, runId: input.runId });
+      return null;
+    }
+    const testProcess = process.env.NODE_ENV === 'test' || !!process.env.ELANOUS_TEST_HOME;
+    if (!seams.readDrafts && !seams.appendDraft && (!seams.stateRoot || (testProcess && seams.stateRoot === elanousStateRoot()))) return null;
+    const stateRoot = seams.stateRoot ?? elanousStateRoot();
+    const cellId = followUpCellId(input);
+    if (!cellId) {
+      log('self-implement.follow-up', 'draft-skipped-no-cell', { ending: 'blocked', prNumber, runId: input.runId });
+      return null;
+    }
+    const prior = (seams.readDrafts ?? ((id) => defaultReadDrafts(stateRoot, id)))(cellId);
+    const key = followUpRecordKey({ ending: 'blocked', runId: input.runId, prNumber });
+    if (prior.some((record) => followUpRecordKey(record) === key)) return null;
+    if (!seams.readDrafts && defaultRecordExists(stateRoot, key)) return null;
+    const depth = followUpChainDepth(prior) + 1;
+    const firstLine = originalAskFirstLine(input.feature);
+    const mode = seams.mode ?? readFollowUpMode();
+    const overDepth = depth > FOLLOW_UP_DEPTH_LIMIT;
+    const draft = overDepth ? undefined : followUpDraftText(firstLine, remainings);
+    const record: FollowUpDraftRecord = {
+      ending: 'blocked', runId: input.runId, stage: input.stage, prNumber, cellId, depth,
+      draftHash: followUpDraftHash(draft ?? `${firstLine}\n${FOLLOW_UP_OP_CARD_REQUIRED}`),
+      kind: overDepth ? 'op-card-required' : 'draft', originalAskFirstLine: firstLine, remainings,
+      ...(draft ? { draft } : {}),
+      ...(overDepth ? { note: FOLLOW_UP_OP_CARD_REQUIRED } : {}),
+      queued: false,
+    };
+    if (seams.appendDraft) seams.appendDraft(record);
+    else if (!defaultAppendFirst(stateRoot, record)) return null;
+    log('self-implement.follow-up', 'drafted', { ending: 'blocked', prNumber, runId: input.runId, stage: input.stage, cellId, depth, kind: record.kind, mode, queued: false, remainingCount: remainings.length });
+    return record;
+  } catch (error) {
+    log('self-implement.follow-up', 'draft-failed', { ending: 'blocked', prNumber, runId: input.runId, stage: input.stage, error: error instanceof Error ? error.message : String(error) });
+    return null;
+  }
+}

package/src/self-implement/gate-baseline-reap.ts

@@ -0,0 +1,157 @@
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, isAbsolute, join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { runGitCommand, type GitCommandRunner } from '../git-fs/runner.js';
+
+export interface GateWorktreeReapResult {
+  ok: boolean;
+  listed: number;
+  candidates: number;
+  removed: number;
+  keptLive: number;
+  keptYoung: number;
+  deferred: number;
+  failed: number;
+  orphanDirsRemoved: number;
+}
+
+export interface GateWorktreeReapOptions {
+  prefixes?: readonly string[];
+  minAgeMs?: number;
+  max?: number;
+}
+
+export interface GateWorktreeReapDeps {
+  run?: GitCommandRunner;
+  isPidAlive?: (pid: number) => boolean;
+  now?: () => number;
+  tmpRoots?: readonly string[];
+}
+
+interface Registration { path: string; reason?: string }
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+function registrations(output: string): Registration[] {
+  return output.split(/\n\s*\n/).flatMap((block) => {
+    const lines = block.split('\n');
+    const path = lines.find((line) => line.startsWith('worktree '))?.slice('worktree '.length);
+    if (!path || !isAbsolute(path)) return [];
+    return [{ path: resolve(path), reason: lines.find((line) => line.startsWith('locked '))?.slice('locked '.length) }];
+  });
+}
+
+function metadataFor(path: string, metadataRoot: string): string | undefined {
+  for (const entry of readdirSync(metadataRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const folder = join(metadataRoot, entry.name);
+    const gitdir = join(folder, 'gitdir');
+    try {
+      if (!lstatSync(gitdir).isFile()) continue;
+      const target = readFileSync(gitdir, 'utf8').trim();
+      if (isAbsolute(target) && resolve(target) === join(path, '.git')) return folder;
+    } catch { continue; }
+  }
+  return undefined;
+}
+
+/** Only gate-prefixed registrations and direct children of the supplied temp roots are eligible. */
+export function reapStaleGateWorktrees(
+  cwd: string,
+  opts: GateWorktreeReapOptions = {},
+  deps: GateWorktreeReapDeps = {},
+): GateWorktreeReapResult {
+  const result: GateWorktreeReapResult = {
+    ok: false, listed: 0, candidates: 0, removed: 0, keptLive: 0,
+    keptYoung: 0, deferred: 0, failed: 0, orphanDirsRemoved: 0,
+  };
+  const emit = (): GateWorktreeReapResult => {
+    if (!result.ok || result.candidates > 0) debug.log('self-implement.gate-baseline', 'reap', { ...result });
+    return result;
+  };
+  const run = deps.run ?? runGitCommand;
+  const git = (args: string[]) => run(cwd, args, { encoding: 'utf8', timeout: 60_000 });
+  try {
+    const listing = git(['worktree', 'list', '--porcelain']);
+    if (listing.status !== 0 || listing.signal || typeof listing.stdout !== 'string') return emit();
+    if (!listing.stdout.startsWith('worktree ')) return emit();
+    const entries = registrations(listing.stdout);
+    result.ok = true;
+    result.listed = entries.length;
+    const prefixes = opts.prefixes ?? ['elanous-gate-baseline-'];
+    const minAgeMs = opts.minAgeMs ?? 2 * 60 * 60_000;
+    const max = Math.max(0, opts.max ?? 20);
+    const now = (deps.now ?? Date.now)();
+    const isAlive = deps.isPidAlive ?? pidAlive;
+    const registered = new Set(entries.map((entry) => entry.path));
+    const matches = (path: string) => prefixes.some((prefix) => prefix.length > 0 && basename(path).startsWith(prefix));
+    const candidates = entries.filter((entry) => matches(entry.path));
+    result.candidates = candidates.length;
+    let metadataRoot: string | undefined;
+    const getMetadataRoot = (): string | undefined => {
+      if (metadataRoot) return metadataRoot;
+      const common = git(['rev-parse', '--git-common-dir']);
+      if (common.status !== 0 || typeof common.stdout !== 'string' || !common.stdout.trim()) return undefined;
+      const root = common.stdout.trim();
+      metadataRoot = join(realpathSync(isAbsolute(root) ? root : resolve(cwd, root)), 'worktrees');
+      return metadataRoot;
+    };
+    let attempted = 0;
+    for (const entry of candidates) {
+      try {
+        const owner = entry.reason?.match(/^elanous-gate pid=([1-9]\d*)\b/);
+        if (owner && isAlive(Number(owner[1]))) {
+          result.keptLive++;
+          continue;
+        }
+        const started = owner ? entry.reason?.match(/\bstarted=(\d+)\b/) : undefined;
+        const startedAt = started ? Number(started[1]) : undefined;
+        const root = startedAt === undefined || !existsSync(entry.path) ? getMetadataRoot() : undefined;
+        const metadata = root ? metadataFor(entry.path, root) : undefined;
+        const timestamp = startedAt !== undefined && Number.isSafeInteger(startedAt)
+          ? startedAt : metadata ? statSync(metadata).mtimeMs : undefined;
+        if (timestamp === undefined || !Number.isFinite(timestamp)) { result.failed++; continue; }
+        if (now - timestamp < minAgeMs) { result.keptYoung++; continue; }
+        if (attempted >= max) { result.deferred++; continue; }
+        attempted++;
+        const removed = git(['worktree', 'remove', '--force', '--force', entry.path]);
+        if (removed.status === 0) { result.removed++; continue; }
+        // A missing checkout cannot be removed by git. Verify the single metadata record before unlinking it.
+        if (!existsSync(entry.path) && metadata && metadataFor(entry.path, root!) === metadata) {
+          rmSync(metadata, { recursive: true });
+          result.removed++;
+        } else result.failed++;
+      } catch { result.failed++; }
+    }
+    for (const root of deps.tmpRoots ?? [realpathSync(tmpdir())]) {
+      try {
+        const realRoot = realpathSync(root);
+        for (const entry of readdirSync(realRoot, { withFileTypes: true })) {
+          const path = join(realRoot, entry.name);
+          if (!entry.isDirectory() || !matches(path) || registered.has(path)) continue;
+          try {
+            const stat = lstatSync(path);
+            if (!stat.isDirectory() || now - stat.mtimeMs < minAgeMs) continue;
+            // A checkout owned by another repository is absent from this repository's listing.
+            // Its .git file (or directory) must never be treated as an unregistered orphan.
+            // With no .git, only an empty directory is provably unused; preserve unknown contents.
+            if (existsSync(join(path, '.git')) || readdirSync(path).length !== 0) continue;
+            rmSync(path, { recursive: true });
+            result.orphanDirsRemoved++;
+          } catch { result.failed++; }
+        }
+      } catch { result.failed++; }
+    }
+  } catch {
+    result.ok = false;
+  }
+  return emit();
+}

package/src/self-implement/gate-baseline.ts

@@ -6,6 +6,7 @@ import { prepareDeterministicChildEnvironment } from '../../scripts/lib/determin
 import { debug } from '../debug/log.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import { linkWorktreeDependencies } from '../git-fs/worktree.js';
+import { reapStaleGateWorktrees } from './gate-baseline-reap.js';
 
 export type GateFailureAttribution = 'introduced' | 'preexisting' | 'unknown' | 'precondition-unmet' | 'flaky-timeout' | 'flaky-rerun';
 export type GateBaselinePresence = 'present' | 'missing' | 'unknown';
@@ -25,7 +26,7 @@ export interface GateTestFailure {
   attribution: GateFailureAttribution;
   /** 기준선 실행 산출과 기존 missingAtBase 입력에서 독립적으로 도출한 파일 존재 상태. */
   baselinePresence: GateBaselinePresence;
-  attributedBy?: 'name-across-files';
+  attributedBy?: 'name-across-files' | 'copied-across-files';
   precondition?: GateFailurePrecondition;
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
@@ -564,6 +565,26 @@ export function classifyGateTestFailures(
         debug.log('self-implement.gate', 'attributed-across-files', { name: path, file: failure.file, baselineFile: baseline.file });
         return { ...failure, attribution: 'preexisting' as const, attributedBy: 'name-across-files' as const, baselinePresence };
       }
+      const baseCandidates = path ? baselineFailures.filter((entry) => testPath(entry) === path) : [];
+      const original = baseCandidates.length === 1 ? baseCandidates[0] : undefined;
+      const currentCandidates = path ? worktreeFailures.filter((entry) => testPath(entry) === path) : [];
+      const currentOriginal = original && currentCandidates.length === 2
+        ? currentCandidates.find((entry) => entry.file === original.file)
+        : undefined;
+      const copies = currentCandidates.filter((entry) => entry.file === failure.file);
+      // Only file position tokens (`[file://]<file>.<ext>:<line>:<col>`, any extension) are erased. A token preceded by `:`, `/`,
+      // a word char, `.` or `-` (URL hosts such as `https://a.example.com:443:10`) is part of the message and stays.
+      const comparableDiagnostic = (diagnostic: string): string =>
+        diagnostic.replace(/(?<![:/\w.-])(?:file:\/\/)?(?:\/?[A-Za-z]:)?[^\s():]+\.[A-Za-z][A-Za-z0-9]*:\d+:\d+/g, '');
+      if (original?.file && original.file !== failure.file && currentOriginal && copies.length === 1
+        && original.diagnostic && currentOriginal.diagnostic && failure.diagnostic
+        && ![original, currentOriginal, failure].some((entry) => isTimeoutDiagnostic(entry.diagnostic)
+          || matchedGatePrecondition(entry.diagnostic ?? ''))
+        && comparableDiagnostic(original.diagnostic) === comparableDiagnostic(currentOriginal.diagnostic)
+        && comparableDiagnostic(original.diagnostic) === comparableDiagnostic(failure.diagnostic)) {
+        debug.log('self-implement.gate', 'attributed-copy-across-files', { name: path, file: failure.file, baselineFile: original.file });
+        return { ...failure, attribution: 'preexisting' as const, attributedBy: 'copied-across-files' as const, baselinePresence };
+      }
       return { ...failure, attribution: 'introduced' as const, baselinePresence };
     }
     if (baselineLog === undefined || !failure.file) return { ...failure, attribution: 'unknown' as const, baselinePresence };
@@ -764,11 +785,52 @@ export function classifyBaselineProcess(result: ProcessResult, budget?: { timeou
   };
 }
 
+let lastGateWorktreeReapAt = 0;
+
+function reapBeforeGateAdd(cwd: string): void {
+  const now = Date.now();
+  if (now - lastGateWorktreeReapAt < 10 * 60_000) return;
+  lastGateWorktreeReapAt = now;
+  try {
+    reapStaleGateWorktrees(cwd);
+  } catch (error) {
+    debug.log('self-implement.gate-baseline', 'reap', { ok: false, error: String(error) });
+  }
+}
+
+function gateWorktreeAddArgs(dir: string, ref: string): string[] {
+  return ['worktree', 'add', '--detach', '--lock', '--reason', `elanous-gate pid=${process.pid} started=${Date.now()}`, dir, ref];
+}
+
+function removeGateWorktree(cwd: string, dir: string, addFailed: boolean): void {
+  try {
+    const registered = addFailed
+      ? runGitCommand(cwd, ['worktree', 'list', '--porcelain'], { encoding: 'utf8', timeout: 60_000 })
+      : undefined;
+    if (addFailed) {
+      // git lists real paths (macOS tmpdir() is /var/… while git prints /private/var/…).
+      let real = dir;
+      try { real = realpathSync(dir); } catch { /* dir already gone: compare the spelling we have */ }
+      const lines = registered?.status === 0 ? (registered.stdout ?? '').split('\n') : [];
+      if (!lines.includes(`worktree ${dir}`) && !lines.includes(`worktree ${real}`)) return;
+    }
+    const removed = runGitCommand(cwd, ['worktree', 'remove', '--force', '--force', dir], { encoding: 'utf8', timeout: 60_000 });
+    if (removed.status !== 0) debug.log('self-implement', 'gate.baseline.cleanup', {
+      stage: addFailed ? 'add-failed-remove' : 'worktree-remove', dir, status: removed.status,
+    });
+  } catch (error) {
+    debug.log('self-implement', 'gate.baseline.cleanup', {
+      stage: addFailed ? 'add-failed-remove' : 'worktree-remove', dir, status: null, error: String(error),
+    });
+  }
+}
+
 export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (baselineDir: string) => T): T | BaselineProcessResult {
+  reapBeforeGateAdd(cwd);
   const baselineDir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
   let attached = false;
   try {
-    const add = runGitCommand(cwd, ['worktree', 'add', '--detach', baselineDir, baseRef], { encoding: 'utf8', timeout: 60_000 });
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(baselineDir, baseRef), { encoding: 'utf8', timeout: 60_000 });
     if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
     attached = true;
     linkDependencies(cwd, baselineDir);
@@ -781,8 +843,12 @@ export function withBaselineWorktree<T>(cwd: string, baseRef: string, run: (base
       log: `baseline setup failed: ${String(error)}`,
     };
   } finally {
-    if (attached) runGitCommand(cwd, ['worktree', 'remove', '--force', baselineDir], { encoding: 'utf8', timeout: 60_000 });
-    rmSync(baselineDir, { recursive: true, force: true });
+    removeGateWorktree(cwd, baselineDir, !attached);
+    try {
+      rmSync(baselineDir, { recursive: true, force: true });
+    } catch (error) {
+      debug.log('self-implement', 'gate.baseline.cleanup', { stage: 'exception', dir: baselineDir, error: String(error) });
+    }
   }
 }
 
@@ -792,11 +858,12 @@ function linkDependencies(cwd: string, dir: string): void {
 }
 
 function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string) => T): T | BaselineProcessResult {
+  reapBeforeGateAdd(cwd);
   let dir = '';
   let attached = false;
   try {
     dir = mkdtempSync(join(tmpdir(), 'elanous-gate-baseline-'));
-    const add = runGitCommand(cwd, ['worktree', 'add', '--detach', dir, baseRef], { encoding: 'utf8', timeout: 60_000 });
+    const add = runGitCommand(cwd, gateWorktreeAddArgs(dir, baseRef), { encoding: 'utf8', timeout: 60_000 });
     if (add.status !== 0) return classifyBaselineProcess({ status: add.status, stdout: add.stdout, stderr: add.stderr });
     attached = true;
     linkDependencies(cwd, dir);
@@ -805,20 +872,15 @@ function withVerifyWorktree<T>(cwd: string, baseRef: string, run: (dir: string)
     const reason = `baseline setup failed: ${String(error)}`;
     return { status: 'unknown', log: reason, output: reason };
   } finally {
-    try {
-      const removed = attached
-        ? runGitCommand(cwd, ['worktree', 'remove', '--force', dir], { encoding: 'utf8', timeout: 60_000 })
-        : undefined;
-      if (removed && removed.status !== 0) {
+    if (dir) {
+      removeGateWorktree(cwd, dir, !attached);
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch (error) {
         debug.log('self-implement', 'gate.verify-by-breaking.cleanup', {
-          stage: 'worktree-remove', dir, status: removed.status, stderr: (removed.stderr ?? '').slice(0, 300),
+          stage: 'exception', dir, error: String(error).slice(0, 300),
         }, { level: 'warn' });
       }
-      if (dir) rmSync(dir, { recursive: true, force: true });
-    } catch (error) {
-      debug.log('self-implement', 'gate.verify-by-breaking.cleanup', {
-        stage: 'exception', dir, error: String(error).slice(0, 300),
-      }, { level: 'warn' });
     }
   }
 }

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

@@ -118,6 +118,9 @@ export interface SelfGateCliResult {
   /** New vs. already-present failures (unknown/preconditionUnmet = failures it could not classify). Absent = the test
    *  step did not produce a measurement (e.g. shards unmeasured). */
   baseline?: { introduced: number; preexisting: number; unknown: number; preconditionUnmet: number };
+  /** LIGHT-RC-MEASURE ③ — why the sharded test step produced no measurement (the same text as the
+   *  `shards: unmeasured (…)` line). Absent when it measured, or on the unsharded path. */
+  unmeasuredReason?: string;
 }
 
 /** 시험 단계와 독립인 정책 관문 넷. skipTestStep 이든 시험 통과든 같은 함수를 부른다. */
@@ -667,10 +670,16 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   if (options.shards !== undefined) {
     const sharded = (deps.runShards ?? runShardedGateTests)(cwd, testFiles, selection.baseRef, options.shards);
     lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})${sharded.measurementFailures ? ` · 측정 실패 ${sharded.measurementFailures}` : ''}`);
-    for (const attempt of sharded.attempts) lines.push(`shard attempt: ${attempt.shardId} #${attempt.attempt}`);
+    // 조각이 «못 쟀다»일 때 이유가 줄에 없으면 자리·시간 초과·죽음을 가를 수 없다(OP 10-09 light RC) — 종료 코드·신호를 같이 싣는다.
+    const side = (code: number | null, signal: string | null | undefined, junit: string | undefined) => signal ? `signal ${signal}` : code === null ? 'exit ?' : `exit ${code}${junit === undefined ? ' · junit 없음' : ''}`;
+    for (const attempt of sharded.attempts) lines.push(`shard attempt: ${attempt.shardId} #${attempt.attempt} · 지금 ${side(attempt.currentExitCode, attempt.currentSignal, attempt.currentJUnit)} · 기준 ${side(attempt.baselineExitCode, attempt.baselineSignal, attempt.baselineJUnit)}`);
     const { aggregate } = sharded;
     let shardBaseline: SelfGateCliResult['baseline'];
-    if (aggregate.status === 'unmeasured') lines.push(`shards: unmeasured (${aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit'})`);
+    let unmeasuredReason: string | undefined;
+    if (aggregate.status === 'unmeasured') {
+      unmeasuredReason = aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit';
+      lines.push(`shards: unmeasured (${unmeasuredReason})`);
+    }
     else if (aggregate.report) {
       const report = aggregate.report;
       logGateCliBaseline(cwd, {
@@ -692,6 +701,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
       lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
       documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
       alwaysIncludeMissing, ...(shardBaseline ? { baseline: shardBaseline } : {}),
+      ...(unmeasuredReason !== undefined ? { unmeasuredReason } : {}),
     };
   }
 

package/src/self-implement/gate-remote.ts

@@ -156,6 +156,8 @@ export interface RemoteRunOptions {
   repo: string;
   host: string;
   mirror: string;
+  /** Exact local commit to run instead of HEAD; permits a dirty worktree. */
+  commit?: string;
   /** argv run from the remote checkout root, e.g. ['bun', 'bin/elanous.mjs', 'self', 'gate', ...]; a function receives
    *  `sha(ref)` for each of `refs` so the remote command names the exact commit, not a ref the host may not have. */
   argv: RemoteArgv;
@@ -233,12 +235,21 @@ function revParse(runner: GateRemoteRunner, repo: string, ref: string): string |
 
 export function runOnRemote(opts: RemoteRunOptions, runner: GateRemoteRunner = realGateRemoteRunner): RemoteRunOutcome {
   const started = Date.now();
-  const status = runner.local('git', ['status', '--porcelain'], opts.repo);
-  if (status.rc !== 0) return { kind: 'infra', reason: 'git-status-failed' };
-  // A remote checkout can only reproduce a commit — uncommitted or untracked files would silently not be measured.
-  if (status.stdout.trim()) return { kind: 'infra', reason: 'dirty-tree' };
-  const commit = revParse(runner, opts.repo, 'HEAD');
-  if (!commit) return { kind: 'infra', reason: 'head-unresolved' };
+  let commit: string;
+  if (opts.commit !== undefined) {
+    if (!shaPattern.test(opts.commit)) return { kind: 'infra', reason: 'invalid-commit' };
+    const object = runner.local('git', ['cat-file', '-t', opts.commit], opts.repo);
+    if (object.rc !== 0 || object.stdout.trim() !== 'commit') return { kind: 'infra', reason: 'commit-missing' };
+    commit = opts.commit;
+  } else {
+    const status = runner.local('git', ['status', '--porcelain'], opts.repo);
+    if (status.rc !== 0) return { kind: 'infra', reason: 'git-status-failed' };
+    // A remote checkout can only reproduce a commit — uncommitted or untracked files would silently not be measured.
+    if (status.stdout.trim()) return { kind: 'infra', reason: 'dirty-tree' };
+    const head = revParse(runner, opts.repo, 'HEAD');
+    if (!head) return { kind: 'infra', reason: 'head-unresolved' };
+    commit = head;
+  }
   // Every check measures against merge-base(origin/main); without the local one the host would fall back to its mirror's
   // (possibly stale) branch — not the same measurement.
   const mainSha = revParse(runner, opts.repo, 'origin/main');