elanous 0.2.32 → 0.2.35

package/src/pr-tool/census.ts

@@ -5,12 +5,17 @@ import { join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import { resolveHostId } from '../platform/host-id.js';
+import { spawnSync } from 'node:child_process';
 
 export interface PrToolCommandResult { ok: boolean; out: string; err?: string }
 export type PrToolCommand = (command: string, args: readonly string[], opts?: { cwd?: string }) => PrToolCommandResult;
+export interface PrToolCall { command: string; args: readonly string[]; opts?: { cwd?: string } }
+/** PR-CENSUS-PARALLEL: run every call with at most `concurrency` in flight; results stay in input order. */
+export type PrToolParallelCommand = (calls: readonly PrToolCall[], concurrency: number) => PrToolCommandResult[];
 export type Seat = 'OP' | 'TC' | 'MK' | 'UX';
 export interface OpenPr {
   number: number;
+  headRefName?: string;
   title: string;
   draft: boolean;
   updatedAt: string;
@@ -20,6 +25,10 @@ export interface OpenPr {
   seat: Seat | null;
   lastCommitAt?: string;
   cellId: string | null;
+  cardId?: string | null;
+  cardMarkerPresent?: boolean;
+  /** «조각 i/N — 부모 <칸>» 표지가 있으면 그 조각 번호(없으면 null) — sibling-slice 판정용. */
+  slice?: { slice: number; total: number } | null;
   hunks?: readonly DiffHunk[];
 }
 export type Inventory = { status: 'checked'; prs: readonly OpenPr[] } | { status: 'unknown'; reason: string };
@@ -31,7 +40,9 @@ export type GuardCode = 'inventory-unknown' | 'candidate-unknown' | 'goal-only'
 export interface GuardReason { code: GuardCode; detail: string; prs?: readonly number[]; files?: readonly string[] }
 /** PR-GUARD-HUNK-WARN (대표 10-17): 줄 겹침은 기본 경고 — 착지 쪽 스마트 머지가 푼다. 'refuse' = 옛 거부 동작. */
 export type HunkOverlapMode = 'refuse' | 'warn';
-export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[] }
+export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[];
+  sameCellConflicts?: readonly { pr: number; cardId: string | null; slice?: { slice: number; total: number } | null }[];
+  sameCellReuse?: { number: number; branch: string; headSha: string; cellId: string; cardId: string; legacyBound?: true } }
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 const DEFAULT_SEAT_CAP = 30;
@@ -41,6 +52,126 @@ const MAX_FILES = 3000; // GitHub does not expose more than 3000 PR files.
 const UNMEASURED_WINDOW_MS = 60 * 60 * 1000;
 const UNMEASURED_ALLOW_COUNT = 3;
 
+export const DEFAULT_DIFF_CONCURRENCY = 6;
+const DIFF_CACHE_MAX = 2000;
+const DIFF_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+const DIFF_CACHE_ENTRY_MAX_BYTES = 4 * 1024 * 1024;
+const PARALLEL_CALL_TIMEOUT_MS = 120_000;
+/** Whole pool ceiling, independent of the call count — a stuck pool fails (inventory unknown) instead of hanging the guard. */
+const PARALLEL_POOL_TIMEOUT_MS = 10 * 60 * 1000;
+const PARALLEL_MAX_BUFFER = 256 * 1024 * 1024;
+
+/** `gh pr diff` patches keyed by PR number ⊕ head sha. A head sha fixes the diff, so a retry or a second guard
+ *  call in the same process never refetches it. Bounded by entry count and total bytes (the oldest entry leaves
+ *  first); a single patch above the per-entry limit is not cached at all. */
+export class CensusDiffCache {
+  private readonly entries = new Map<string, { patch: string; bytes: number }>();
+  private totalBytes = 0;
+  constructor(private readonly max = DIFF_CACHE_MAX, private readonly maxBytes = DIFF_CACHE_MAX_BYTES,
+    private readonly entryMaxBytes = DIFF_CACHE_ENTRY_MAX_BYTES) {}
+  private key(number: number, headSha: string): string { return `${number}@${headSha}`; }
+  private drop(key: string): void {
+    const entry = this.entries.get(key);
+    if (!entry) return;
+    this.totalBytes -= entry.bytes;
+    this.entries.delete(key);
+  }
+  get(number: number, headSha: string): string | undefined { return this.entries.get(this.key(number, headSha))?.patch; }
+  set(number: number, headSha: string, patch: string): void {
+    const key = this.key(number, headSha);
+    this.drop(key);
+    const bytes = Buffer.byteLength(patch, 'utf8');
+    if (bytes > this.entryMaxBytes || bytes > this.maxBytes) return;
+    while (this.entries.size > 0 && (this.entries.size >= this.max || this.totalBytes + bytes > this.maxBytes)) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) break;
+      this.drop(oldest);
+    }
+    this.entries.set(key, { patch, bytes });
+    this.totalBytes += bytes;
+  }
+  get size(): number { return this.entries.size; }
+  get bytes(): number { return this.totalBytes; }
+  clear(): void { this.entries.clear(); this.totalBytes = 0; }
+}
+/** Process-lifetime cache for production callers (PR creation guard · `pr open-guard`). Tests pass their own. */
+export const sharedCensusDiffCache = new CensusDiffCache();
+export function resetCensusDiffCache(): void { sharedCensusDiffCache.clear(); }
+
+// Runs inside a child `bun`/`node` so the synchronous inventory API can still fan out. stdin: { calls, concurrency,
+// timeoutMs } · stdout: one result per call, input order. Each call runs in its own process group (detached) so a
+// per-call timeout, or this pool ending on SIGTERM/SIGINT/SIGHUP from the outer ceiling, kills the whole group —
+// no `gh` (or its children) outlives the pool.
+const PARALLEL_SCRIPT = `
+const { spawn } = require('node:child_process');
+const live = new Set();
+const killGroup = pid => { try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} } };
+const killAll = () => { for (const pid of live) killGroup(pid); live.clear(); };
+for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.on(signal, () => { killAll(); process.exit(124); });
+process.on('exit', killAll);
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  const { calls, concurrency, timeoutMs } = JSON.parse(input);
+  const results = new Array(calls.length);
+  let next = 0;
+  const one = index => new Promise(resolve => {
+    const call = calls[index];
+    const out = []; const err = [];
+    let settled = false; let timedOut = false; let timer;
+    let child;
+    const finish = result => {
+      if (settled) return; settled = true; clearTimeout(timer);
+      if (child && child.pid) { killGroup(child.pid); live.delete(child.pid); }
+      results[index] = result; resolve();
+    };
+    try { child = spawn(call.command, call.args, { cwd: call.cwd || undefined, stdio: ['ignore', 'pipe', 'pipe'], detached: true }); }
+    catch (error) { results[index] = { ok: false, out: '', err: String(error && error.message || error) }; resolve(); return; }
+    if (child.pid) live.add(child.pid);
+    timer = setTimeout(() => { timedOut = true; if (child.pid) killGroup(child.pid); }, timeoutMs);
+    child.stdout.on('data', chunk => out.push(chunk));
+    child.stderr.on('data', chunk => err.push(chunk));
+    child.on('error', error => finish({ ok: false, out: '', err: String(error && error.message || error) }));
+    child.on('close', (code, signal) => finish({ ok: code === 0 && !signal && !timedOut, out: Buffer.concat(out).toString('utf8').trim(),
+      err: [Buffer.concat(err).toString('utf8').trim(), timedOut ? 'timed out after ' + timeoutMs + 'ms' : signal ? 'terminated by ' + signal : ''].filter(Boolean).join('\\n') }));
+  });
+  const worker = async () => { while (next < calls.length) { const index = next++; await one(index); } };
+  Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, calls.length)) }, worker))
+    .then(() => process.stdout.write(JSON.stringify(results)));
+});
+`;
+
+/** Real-spawn {@link PrToolParallelCommand}: one child runtime fans out the calls with a bounded pool. Any failure of
+ *  the pool itself (including the fixed pool ceiling) returns every call as failed, so the caller's conservative
+ *  unknown rule applies. `timeoutMs` = per call · `poolTimeoutMs` = whole pool (tests inject short values). */
+export function spawnParallelCommands(calls: readonly PrToolCall[], options: { concurrency?: number; env?: NodeJS.ProcessEnv; timeoutMs?: number; poolTimeoutMs?: number } = {}): PrToolCommandResult[] {
+  if (calls.length === 0) return [];
+  const concurrency = Math.max(1, Math.floor(options.concurrency ?? DEFAULT_DIFF_CONCURRENCY));
+  const timeoutMs = options.timeoutMs ?? PARALLEL_CALL_TIMEOUT_MS;
+  const failAll = (err: string) => calls.map(() => ({ ok: false, out: '', err }));
+  try {
+    const r = spawnSync(process.execPath, ['-e', PARALLEL_SCRIPT], {
+      input: JSON.stringify({ calls: calls.map(call => ({ command: call.command, args: [...call.args], cwd: call.opts?.cwd })), concurrency, timeoutMs }),
+      encoding: 'utf-8', maxBuffer: PARALLEL_MAX_BUFFER, timeout: options.poolTimeoutMs ?? PARALLEL_POOL_TIMEOUT_MS, killSignal: 'SIGTERM',
+      ...(options.env ? { env: options.env } : {}),
+    });
+    if ((r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS') return failAll('parallel output exceeded 256MiB (ENOBUFS)');
+    if ((r.error as NodeJS.ErrnoException | undefined)?.code === 'ETIMEDOUT' || r.signal) return failAll(`parallel runner timed out or was killed (${r.signal ?? 'ETIMEDOUT'})`);
+    if (r.status !== 0) return failAll(`parallel runner rc=${r.status}: ${(r.stderr ?? '').trim().slice(0, 300)}`);
+    const parsed: unknown = JSON.parse(r.stdout ?? '');
+    if (!Array.isArray(parsed) || parsed.length !== calls.length) return failAll('parallel runner result shape mismatch');
+    return parsed.map(row => {
+      const value = row as { ok?: unknown; out?: unknown; err?: unknown } | null;
+      return value && typeof value.ok === 'boolean' && typeof value.out === 'string'
+        ? { ok: value.ok, out: value.out, err: typeof value.err === 'string' ? value.err : '' }
+        : { ok: false, out: '', err: 'parallel runner row missing' };
+    });
+  } catch (error) {
+    return failAll(`parallel runner: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 function unknown(reason: string): Inventory { return { status: 'unknown', reason }; }
 function seatValue(value: unknown): Seat | null { return SEATS.find(seat => seat === value) ?? null; }
 function seatFromLabels(labels: readonly string[]): Seat | null {
@@ -49,6 +180,22 @@ function seatFromLabels(labels: readonly string[]): Seat | null {
 export function cellIdFromBody(body: string): string | null {
   return /^\s*(?:[-*]\s*)?칸\s*:\s*([A-Z][A-Z0-9-]{2,})\s*$/m.exec(body)?.[1] ?? null;
 }
+export function cardIdFromBody(body: string): string | null {
+  const ids = [...body.matchAll(/^\s*(?:[-*]\s*)?카드\s*:\s*([^\r\n]*)$/gm)].map(match => match[1]!.trim());
+  return ids.length > 0 && ids.every(id => /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(id) && id === ids[0]) ? ids[0]! : null;
+}
+export function hasCardMarker(body: string): boolean {
+  return /^\s*(?:[-*]\s*)?카드\s*:/m.test(body);
+}
+/** 골/PR 본문의 «조각 i/N — 부모 <칸>» 표지 → {slice,total}. 표지 없으면 null, 1≤i≤N 아니면 null. */
+export function sliceMarkerFromBody(body: string): { slice: number; total: number } | null {
+  const m = /^\s*(?:[-*]\s*)?(?:«\s*)?조각\s*(\d+)\s*\/\s*(\d+)\s*(?:»)?\s*—\s*부모\s+\S[^\r\n]*$/m.exec(body);
+  if (!m) return null;
+  const slice = Number(m[1]);
+  const total = Number(m[2]);
+  return Number.isSafeInteger(slice) && Number.isSafeInteger(total) && slice >= 1 && total >= 1 && slice <= total
+    ? { slice, total } : null;
+}
 
 export function parseDiffHunks(patch: string): DiffHunk[] {
   const hunks: DiffHunk[] = [];
@@ -81,8 +228,8 @@ export function parseDiffHunks(patch: string): DiffHunk[] {
 }
 
 /** `gh api --paginate --slurp` must return every REST page, including the last page. */
-function pages(run: PrToolCommand, endpoint: string, cwd?: string): readonly unknown[] {
-  const result = run('gh', ['api', '--paginate', '--slurp', endpoint], cwd ? { cwd } : undefined);
+function pagesArgs(endpoint: string): string[] { return ['api', '--paginate', '--slurp', endpoint]; }
+function parsePages(result: PrToolCommandResult, endpoint: string): readonly unknown[] {
   if (!result.ok) throw new Error(`gh api ${endpoint}: ${result.err || result.out || '조회 실패'}`);
   let parsed: unknown;
   try { parsed = JSON.parse(result.out); } catch { throw new Error(`gh api ${endpoint}: JSON 오류`); }
@@ -91,6 +238,9 @@ function pages(run: PrToolCommand, endpoint: string, cwd?: string): readonly unk
   }
   return parsed.flat();
 }
+function pages(run: PrToolCommand, endpoint: string, cwd?: string): readonly unknown[] {
+  return parsePages(run('gh', pagesArgs(endpoint), cwd ? { cwd } : undefined), endpoint);
+}
 
 function object(value: unknown): Record<string, unknown> {
   if (value === null || typeof value !== 'object' || Array.isArray(value)) throw new Error('PR 응답 행 형식 오류');
@@ -105,29 +255,59 @@ function date(value: unknown, name: string): string {
   if (!Number.isFinite(Date.parse(raw))) throw new Error(`${name} 날짜 오류`);
   return raw;
 }
-function pathsForPr(run: PrToolCommand, number: number, cwd?: string): string[] {
-  const rows = pages(run, `repos/{owner}/{repo}/pulls/${number}/files?per_page=100`, cwd);
+function filesEndpoint(number: number): string { return `repos/{owner}/{repo}/pulls/${number}/files?per_page=100`; }
+function pathsFromFilesResult(result: PrToolCommandResult, number: number): string[] {
+  const rows = parsePages(result, filesEndpoint(number));
   if (rows.length >= MAX_FILES) throw new Error(`PR #${number}: 파일 ${MAX_FILES}개 GitHub 상한에 닿음`);
   return rows.map(row => text(object(row).filename, `PR #${number} 파일명`));
 }
 
-/** Fast file projection; the REST page census below remains the authority for which PRs exist. */
-function projectedFiles(run: PrToolCommand, count: number, cwd?: string): Map<number, string[]> {
+interface FileProjection {
+  files: Map<number, string[]>;
+  /** Set when the one-shot list produced nothing usable — every PR then takes the REST file fallback. */
+  failure?: string;
+  /** Rows the projection could not vouch for (malformed · file list shorter than changedFiles, e.g. >100 files). */
+  skipped: number;
+}
+
+/** Fast file projection; the REST page census below remains the authority for which PRs exist. A failed or partial
+ *  projection is never silent: the reason and skipped row count go to the `diff-scan` observation. */
+function projectedFiles(run: PrToolCommand, count: number, cwd?: string): FileProjection {
   const result = run('gh', ['pr', 'list', '--state', 'open', '--limit', String(Math.max(count, 1)), '--json', 'number,changedFiles,files'], cwd ? { cwd } : undefined);
-  if (!result.ok) return new Map();
+  if (!result.ok) return { files: new Map(), skipped: 0, failure: `gh pr list 실패: ${(result.err || result.out || 'rc≠0').trim().slice(0, 200)}` };
   let rows: unknown;
-  try { rows = JSON.parse(result.out); } catch { return new Map(); }
-  if (!Array.isArray(rows)) return new Map();
+  try { rows = JSON.parse(result.out); } catch { return { files: new Map(), skipped: 0, failure: `gh pr list JSON 오류 (${result.out.length}자)` }; }
+  if (!Array.isArray(rows)) return { files: new Map(), skipped: 0, failure: 'gh pr list 응답이 배열 아님' };
   const projection = new Map<number, string[]>();
+  let skipped = 0;
   for (const value of rows) {
     try {
       const row = object(value);
-      if (!Number.isSafeInteger(row.number) || (row.number as number) <= 0 || !Number.isSafeInteger(row.changedFiles) || (row.changedFiles as number) < 0 || !Array.isArray(row.files)) continue;
+      if (!Number.isSafeInteger(row.number) || (row.number as number) <= 0 || !Number.isSafeInteger(row.changedFiles) || (row.changedFiles as number) < 0 || !Array.isArray(row.files)) { skipped += 1; continue; }
       const paths = row.files.map(file => text(object(file).path, 'PR 파일명'));
       if (paths.length === row.changedFiles && paths.length < MAX_FILES && !projection.has(row.number as number)) projection.set(row.number as number, paths);
-    } catch { /* malformed projection: REST file endpoint below decides this PR */ }
+      else skipped += 1;
+    } catch { skipped += 1; /* malformed projection: REST file endpoint below decides this PR */ }
+  }
+  if (rows.length > 0 && projection.size === 0) return { files: projection, skipped, failure: `gh pr list ${rows.length}행 모두 사용 불가` };
+  return { files: projection, skipped };
+}
+
+/** Run `calls` through the bounded pool when given, else one by one with the injected runner, stopping at the first
+ *  failure (the historical order and call count). The result may be shorter than `calls` only in that sequential case. */
+function runCalls(run: PrToolCommand, calls: readonly PrToolCall[], runParallel: PrToolParallelCommand | undefined, concurrency: number, what: string): PrToolCommandResult[] {
+  if (runParallel) {
+    const results = runParallel(calls, concurrency);
+    if (results.length !== calls.length) throw new Error(`${what} 결과 ${results.length}/${calls.length}건 · 판정 불가`);
+    return results;
   }
-  return projection;
+  const results: PrToolCommandResult[] = [];
+  for (const call of calls) {
+    const result = run(call.command, call.args, call.opts);
+    results.push(result);
+    if (!result.ok) break;
+  }
+  return results;
 }
 
 export function readOpenPrs(run: PrToolCommand, options: {
@@ -135,10 +315,28 @@ export function readOpenPrs(run: PrToolCommand, options: {
   seatOfPr?: (pr: { number: number; headRefName: string; body: string; labels: readonly string[] }) => Seat | null;
   includeDraftCommitDates?: boolean;
   candidateFiles?: readonly string[];
+  /** Bounded parallel REST-file fallback and diff fetch. Absent ⇒ the injected `run`, one by one (historical order and call count). */
+  runParallel?: PrToolParallelCommand;
+  /** Operations default {@link DEFAULT_DIFF_CONCURRENCY} (6) — production callers do not pass it; for test injection. */
+  diffConcurrency?: number;
+  /** Absent ⇒ no cache. Production callers pass {@link sharedCensusDiffCache}. */
+  diffCache?: CensusDiffCache;
 } = {}): Inventory {
+  const started = Date.now();
+  const callOpts = options.cwd ? { opts: { cwd: options.cwd } } : {};
+  const concurrency = options.runParallel ? Math.max(1, Math.floor(options.diffConcurrency ?? DEFAULT_DIFF_CONCURRENCY)) : 1;
+  const scan = { openPrs: 0, projected: 0, restFallback: 0, projectionFailed: false, projectionReason: undefined as string | undefined,
+    projectionSkipped: 0, fileOverlap: 0, patchFetched: 0, cacheHits: 0 };
+  let status: 'checked' | 'inventory-unknown' | 'files-failed' | 'diff-failed' | 'commit-date-failed' = 'inventory-unknown';
+  const logDiffScan = () => {
+    debug.log('pr-tool.census', 'diff-scan', { ...scan, concurrency, elapsedMs: Date.now() - started, status });
+  };
   try {
     const rows = pages(run, 'repos/{owner}/{repo}/pulls?state=open&per_page=100', options.cwd);
-    const projected = projectedFiles(run, rows.length, options.cwd);
+    const projection = projectedFiles(run, rows.length, options.cwd);
+    scan.projectionFailed = projection.failure !== undefined;
+    scan.projectionReason = projection.failure;
+    scan.projectionSkipped = projection.skipped;
     const prs: OpenPr[] = [];
     const seen = new Set<number>();
     for (const value of rows) {
@@ -155,26 +353,69 @@ export function readOpenPrs(run: PrToolCommand, options: {
       const headSha = text(head.sha, `PR #${number} head sha`);
       const body = typeof row.body === 'string' ? row.body : '';
       const seat = seatValue(options.seatOfPr?.({ number: number as number, headRefName, body, labels: labelNames })) ?? seatFromLabels(labelNames);
-      const pr: OpenPr = {
-        number: number as number, title: text(row.title, `PR #${number} title`), draft: row.draft,
+      prs.push({
+        number: number as number, headRefName, title: text(row.title, `PR #${number} title`), draft: row.draft,
         updatedAt: date(row.updated_at, `PR #${number} updated_at`), headSha, labels: labelNames,
-        files: projected.get(number as number) ?? pathsForPr(run, number as number, options.cwd), seat,
-        cellId: cellIdFromBody(body),
-      };
-      if (options.candidateFiles?.some(file => pr.files.includes(file))) {
-        const patch = run('gh', ['pr', 'diff', String(number), '--patch'], options.cwd ? { cwd: options.cwd } : undefined);
-        if (!patch.ok) throw new Error(`PR #${number}: 수정 줄 조회 실패: ${patch.err || patch.out}`);
+        files: projection.files.get(number as number) ?? [], seat,
+        cellId: cellIdFromBody(body), cardId: cardIdFromBody(body), cardMarkerPresent: hasCardMarker(body),
+        slice: sliceMarkerFromBody(body),
+      });
+    }
+    scan.openPrs = prs.length;
+    // Files: PRs the one-shot projection did not cover take the REST file endpoint — in the pool when given.
+    const restPrs = prs.filter(pr => !projection.files.has(pr.number));
+    scan.projected = prs.length - restPrs.length;
+    scan.restFallback = restPrs.length;
+    if (restPrs.length) {
+      status = 'files-failed';
+      const results = runCalls(run, restPrs.map(pr => ({ command: 'gh', args: pagesArgs(filesEndpoint(pr.number)), ...callOpts })), options.runParallel, concurrency, 'PR 파일 조회');
+      // The first failure in input order decides the reason; one failure keeps the whole inventory unknown.
+      // Invariant: a result is missing only after an earlier failure (sequential stop), which throws first. Still,
+      // a missing result is a failure (unknown), never an empty file list.
+      restPrs.forEach((pr, index) => {
+        const result = results[index];
+        if (!result) throw new Error(`PR #${pr.number}: 파일 조회 결과 없음 · 판정 불가`);
+        pr.files = pathsFromFilesResult(result, pr.number);
+      });
+    }
+    // Diffs: only PRs sharing a candidate file; a cached (number, headSha) patch is not refetched.
+    const pendingDiffs: OpenPr[] = [];
+    for (const pr of prs) {
+      if (!options.candidateFiles?.some(file => pr.files.includes(file))) continue;
+      scan.fileOverlap += 1;
+      const cached = options.diffCache?.get(pr.number, pr.headSha);
+      if (cached !== undefined) { pr.hunks = parseDiffHunks(cached); scan.cacheHits += 1; }
+      else pendingDiffs.push(pr);
+    }
+    if (pendingDiffs.length) {
+      status = 'diff-failed';
+      const results = runCalls(run, pendingDiffs.map(pr => ({ command: 'gh', args: ['pr', 'diff', String(pr.number), '--patch'], ...callOpts })), options.runParallel, concurrency, '수정 줄 조회');
+      scan.patchFetched = results.length;
+      pendingDiffs.forEach((pr, index) => {
+        const patch = results[index];
+        if (!patch) throw new Error(`PR #${pr.number}: 수정 줄 조회 결과 없음 · 판정 불가`);
+        if (!patch.ok) throw new Error(`PR #${pr.number}: 수정 줄 조회 실패: ${patch.err || patch.out}`);
+      });
+      pendingDiffs.forEach((pr, index) => {
+        const patch = results[index]!;
         pr.hunks = parseDiffHunks(patch.out);
+        options.diffCache?.set(pr.number, pr.headSha, patch.out);
+      });
+    }
+    if (options.includeDraftCommitDates) {
+      status = 'commit-date-failed';
+      for (const pr of prs) {
+        if (!pr.draft) continue;
+        const commit = run('gh', ['api', `repos/{owner}/{repo}/commits/${pr.headSha}`, '--jq', '.commit.committer.date'], options.cwd ? { cwd: options.cwd } : undefined);
+        if (!commit.ok) throw new Error(`PR #${pr.number}: 마지막 커밋 날짜 조회 실패: ${commit.err || commit.out}`);
+        pr.lastCommitAt = date(commit.out.trim(), `PR #${pr.number} 마지막 커밋`);
       }
-      if (pr.draft && options.includeDraftCommitDates) {
-        const commit = run('gh', ['api', `repos/{owner}/{repo}/commits/${headSha}`, '--jq', '.commit.committer.date'], options.cwd ? { cwd: options.cwd } : undefined);
-        if (!commit.ok) throw new Error(`PR #${number}: 마지막 커밋 날짜 조회 실패: ${commit.err || commit.out}`);
-        pr.lastCommitAt = date(commit.out.trim(), `PR #${number} 마지막 커밋`);
-      }
-      prs.push(pr);
     }
+    status = 'checked';
+    logDiffScan();
     return { status: 'checked', prs };
   } catch (error) {
+    logDiffScan();
     return unknown(error instanceof Error ? error.message : String(error));
   }
 }
@@ -211,7 +452,7 @@ export function censusOpenPrs(inventory: Inventory, now = Date.now()): Census {
   return result;
 }
 
-export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; hunks?: readonly DiffHunk[]; hunkOverlap?: HunkOverlapMode }, inventory: Inventory): GuardVerdict {
+export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; cardId?: string | null; slice?: { slice: number; total: number } | null; boundPrNumber?: number; hunks?: readonly DiffHunk[]; hunkOverlap?: HunkOverlapMode }, inventory: Inventory): GuardVerdict {
   if (!input.files || input.files.length === 0 || input.files.some(file => !file || file.startsWith('/') || file.includes('..'))) {
     const reasons: GuardReason[] = [{ code: 'candidate-unknown', detail: '새 PR 변경 파일을 확인할 수 없음' }];
     debug.log('pr.tool', 'guard-refuse', { status: 'unknown', reasons });
@@ -260,7 +501,18 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
   const status = reasons.some(reason => reason.code === 'candidate-unknown') ? 'unknown' : reasons.length ? 'refuse' : 'allow';
   if (status !== 'allow') debug.log('pr.tool', 'guard-refuse', { status, reasons, warnings });
   else if (warnings.length) debug.log('pr.tool', 'guard-warn', { warnings });
-  return { status, reasons, warnings };
+  const legacyBound = sameCell.length === 1 && sameCell[0]?.cardMarkerPresent === false
+    && input.boundPrNumber === sameCell[0].number;
+  const reusable = status === 'refuse' && reasons.length === 1 && reasons[0]?.code === 'same-cell'
+    && input.cardId && sameCell.length === 1 && (sameCell[0]?.cardId === input.cardId || legacyBound)
+    && (input.slice?.slice ?? null) === (sameCell[0]?.slice?.slice ?? null)
+    && (input.slice?.total ?? null) === (sameCell[0]?.slice?.total ?? null)
+    && sameCell[0].headRefName && /^[0-9a-f]{40}$/i.test(sameCell[0].headSha)
+    ? { number: sameCell[0].number, branch: sameCell[0].headRefName, headSha: sameCell[0].headSha,
+      cellId: input.cellId!, cardId: input.cardId, ...(legacyBound ? { legacyBound: true as const } : {}) } : undefined;
+  return { status, reasons, warnings,
+    ...(sameCell.length ? { sameCellConflicts: sameCell.map(pr => ({ pr: pr.number, cardId: pr.cardId ?? null, slice: pr.slice ?? null })) } : {}),
+    ...(reusable ? { sameCellReuse: reusable } : {}) };
 }
 
 /** Persist the unknown-read budget across harness processes sharing one instance state root. */

package/src/pr-tool/inflight-registry.ts

@@ -5,17 +5,27 @@
  * 만지는 줄들의 의도를 읽는다. 착지하면 지운다. 정본은 PR 본문이고 이것은 «색인»이다 — 못 읽으면 빈 목록
  * (머지는 종전 그대로 간다), 못 쓰면 발사·착지를 막지 않는다(호출부가 fail-soft).
  *
- * 폭증 막기: 런당 1줄(같은 칸 재발사는 덮어씀) · 의도 ≤300자 · 파일 ≤20 · 48h 지난 줄은 읽을 때 거르고 쓸 때 걷는다.
+ * 폭증 막기: 런당 1줄(같은 칸 재발사는 덮어씀) · 의도 ≤300자 · 파일 ≤20.
+ *
+ * 걷기: 닫힌 PR(`removeInflightForClosedPrs`)·끝난 런(`removeInflightForFinishedRuns`)은 그때 바로 걷고,
+ * 남은 줄은 `gcInflight` 가 6h 시한(`INFLIGHT_GC_TTL_MS`)으로 걷는다 — 6h 넘게 살아 있는 런은 없다.
+ * 48h 지연 필터(`INFLIGHT_TTL_MS`)는 GC 가 한 번도 안 돈 등록부의 백스톱이다(읽기는 쓰지 않는다).
+ *
+ * 쓰기는 임시 파일 → rename 원자 쓰기 — 반쯤 쓴 등록부를 동시에 읽는 쪽이 보지 않는다.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { basename, dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 
 export const INFLIGHT_INTENT_MAX_CHARS = 300;
 export const INFLIGHT_FILES_MAX = 20;
+/** 지연 필터 시한 — GC 가 안 돈 등록부가 머지를 영원히 오염시키지 못하게 하는 백스톱. */
 export const INFLIGHT_TTL_MS = 48 * 60 * 60 * 1000;
+/** GC 시한 — 이만큼 지난 줄은 지금 살아 있는 런이 아니다. */
+export const INFLIGHT_GC_TTL_MS = 6 * 60 * 60 * 1000;
 export const INFLIGHT_REGISTRY_FILE = 'inflight-registry.json';
 
 export interface InflightEntry {
@@ -33,6 +43,53 @@ export interface InflightOptions {
   now?: () => Date;
 }
 
+/** 줄을 연 과제 카드의 최소 모양 — PR 상태(`state`)는 호출부가 gh 로 채워 준다. */
+export interface InflightOwnerCard {
+  id: string;
+  runId?: string;
+  pr?: number | { number: number; state?: string };
+}
+
+export interface InflightGcInput extends InflightOptions {
+  /** 머지 없이 닫힌 PR 번호. */
+  closedPrs?: readonly number[];
+  /** 끝난 런 id — 정상 종료·중단 모두. */
+  finishedRuns?: readonly string[];
+  /** 과제 카드들 — `card.pr` 이 닫힌 PR 이면 그 카드의 줄을 걷는다. */
+  cards?: Iterable<InflightOwnerCard>;
+}
+
+export type InflightGcReason = 'expired' | 'finished-run' | 'closed-pr';
+
+export interface InflightGcResult {
+  /** 걷고 남은 줄 수. */
+  kept: number;
+  removed: Array<{ entry: InflightEntry; reason: InflightGcReason }>;
+}
+
+const CLOSED_PR_STATES = new Set(['CLOSED', 'closed', 'MERGED', 'merged']);
+
+function prNumberOf(card: InflightOwnerCard): number | undefined {
+  return typeof card.pr === 'number' ? card.pr : card.pr?.number;
+}
+
+function isClosedOwner(card: InflightOwnerCard, closedPrs: ReadonlySet<number>): boolean {
+  const pr = card.pr;
+  if (pr === undefined) return false;
+  if (typeof pr === 'object' && pr.state !== undefined && CLOSED_PR_STATES.has(pr.state)) return true;
+  const number = prNumberOf(card);
+  return number !== undefined && closedPrs.has(number);
+}
+
+/** 닫힌 카드들의 카드 id·runId — 줄을 찾는 키. */
+function closedOwnerKeys(cards: readonly InflightOwnerCard[], closedPrs: ReadonlySet<number>): { cardIds: Set<string>; runIds: Set<string> } {
+  const owners = cards.filter((card) => isClosedOwner(card, closedPrs));
+  return {
+    cardIds: new Set(owners.map((card) => card.id)),
+    runIds: new Set(owners.flatMap((card) => (card.runId ? [card.runId] : []))),
+  };
+}
+
 /** 기본 자리 — 과제 카드 상태(`task-agent-actions.json`)와 같은 우주 뿌리. */
 export function inflightRegistryPath(): string {
   return join(effectiveInstanceRoot(), INFLIGHT_REGISTRY_FILE);
@@ -52,9 +109,30 @@ function isEntry(value: unknown): value is InflightEntry {
     && Array.isArray(entry.files) && typeof entry.registeredAt === 'string';
 }
 
-function isExpired(entry: InflightEntry, now: Date): boolean {
+function olderThan(entry: InflightEntry, now: Date, ttlMs: number): boolean {
   const at = Date.parse(entry.registeredAt);
-  return !Number.isFinite(at) || now.getTime() - at > INFLIGHT_TTL_MS;
+  return !Number.isFinite(at) || now.getTime() - at > ttlMs;
+}
+
+function isExpired(entry: InflightEntry, now: Date): boolean {
+  return olderThan(entry, now, INFLIGHT_TTL_MS);
+}
+
+/**
+ * 임시 파일 → rename. 임시 파일은 같은 디렉터리(=같은 파일시스템)에 만들어 rename 이 원자다 —
+ * 읽는 쪽은 «옛 등록부» 아니면 «완성된 새 등록부»만 본다(반쯤 쓴 JSON 을 파싱하지 않는다).
+ */
+function writeEntriesAtomic(path: string, entries: InflightEntry[]): void {
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${basename(path)}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(tmp, `${JSON.stringify({ entries })}\n`, 'utf8');
+    renameSync(tmp, path);
+  } catch (error) {
+    try { unlinkSync(tmp); } catch { /* rename 이 이미 끝났으면 지울 임시 파일이 없다 */ }
+    throw error;
+  }
 }
 
 /** 잠금 안에서 읽고 고쳐 쓴다 — 48h 지난 줄은 쓸 때 걷는다(`expire` 관측). */
@@ -67,11 +145,24 @@ function mutate(opts: InflightOptions, update: (entries: InflightEntry[]) => Inf
     if (live.length < all.length) {
       try { debug.log('pr-tool.inflight', 'expire', { phase: 'write', runIds: all.filter((entry) => isExpired(entry, now)).map((entry) => entry.runId) }); } catch { /* fail-soft */ }
     }
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify({ entries: update(live) }));
+    writeEntriesAtomic(path, update(live));
   });
 }
 
+/** 잠금 한 번·원자 쓰기 한 번으로 걷는다 — 지울 줄이 없으면 디스크를 건드리지 않는다. */
+function sweep(opts: InflightOptions, reason: string, drop: (entry: InflightEntry) => boolean): InflightEntry[] {
+  const path = opts.path ?? inflightRegistryPath();
+  let removed: InflightEntry[] = [];
+  withFileLockSync(`${path}.lock`, () => {
+    const all = readEntries(path);
+    removed = all.filter(drop);
+    if (removed.length === 0) return;
+    writeEntriesAtomic(path, all.filter((entry) => !drop(entry)));
+  });
+  try { debug.log('pr-tool.inflight', 'remove', { reason, removed: removed.map((entry) => entry.runId) }); } catch { /* fail-soft */ }
+  return removed;
+}
+
 /** 한 줄 등록 — 같은 runId 또는 같은 칸의 옛 줄을 덮어쓴다. 의도·파일은 상한에서 자른다. */
 export function registerInflight(input: { runId: string; cell: string; intent: string; files: readonly string[]; cardId?: string }, opts: InflightOptions = {}): InflightEntry {
   const now = (opts.now ?? (() => new Date()))();
@@ -141,3 +232,65 @@ export function removeInflightForPr(
   }
   return removed;
 }
+
+/**
+ * 닫힌 PR(머지 포함)의 줄을 지운다 — `closedPrs` 번호와 `card.pr` 의 닫힘 상태 양쪽을 본다.
+ * 열린 PR 카드는 건드리지 않고, 닫힌 카드가 없으면 디스크도 건드리지 않는다.
+ */
+export function removeInflightForClosedPrs(
+  closedPrs: readonly number[],
+  cards: Iterable<InflightOwnerCard>,
+  opts: InflightOptions = {},
+): number {
+  const closed = new Set(closedPrs);
+  const { cardIds, runIds } = closedOwnerKeys([...cards], closed);
+  if (cardIds.size === 0 && runIds.size === 0) {
+    try { debug.log('pr-tool.inflight', 'remove', { reason: 'pr-closed', removed: [], cards: 0, closedPrs: [...closed] }); } catch { /* fail-soft */ }
+    return 0;
+  }
+  return sweep(opts, `pr-closed:${[...closed].sort((a, b) => a - b).join(',')}`, (entry) => (
+    (entry.cardId !== undefined && cardIds.has(entry.cardId)) || runIds.has(entry.runId)
+  )).length;
+}
+
+/** 끝난 런(정상 종료·중단 모두)의 줄을 지운다 — 카드가 없어도 runId 로 걷는다. */
+export function removeInflightForFinishedRuns(runIds: readonly string[], opts: InflightOptions = {}): number {
+  const finished = new Set(runIds);
+  if (finished.size === 0) return 0;
+  return sweep(opts, 'run-finished', (entry) => finished.has(entry.runId)).length;
+}
+
+/**
+ * 등록부 청소 한 번 — 닫힌 PR 줄 · 끝난 런 줄 · 6h 넘은 줄을 한 잠금·원자 쓰기 한 번으로 걷는다.
+ * 지울 줄이 없으면 디스크를 건드리지 않고, 무엇이 왜 걷혔는지(`reason`)를 돌려준다.
+ * 우선순위: `expired` → `finished-run` → `closed-pr`(한 줄이 여러 규칙에 걸리면 시한이 먼저다).
+ */
+export function gcInflight(input: InflightGcInput = {}): InflightGcResult {
+  const path = input.path ?? inflightRegistryPath();
+  const now = (input.now ?? (() => new Date()))();
+  const finished = new Set(input.finishedRuns ?? []);
+  const { cardIds, runIds } = closedOwnerKeys([...(input.cards ?? [])], new Set(input.closedPrs ?? []));
+  const classify = (entry: InflightEntry): InflightGcReason | null => {
+    if (olderThan(entry, now, INFLIGHT_GC_TTL_MS)) return 'expired';
+    if (finished.has(entry.runId)) return 'finished-run';
+    if (runIds.has(entry.runId)) return 'closed-pr';
+    if (entry.cardId !== undefined && cardIds.has(entry.cardId)) return 'closed-pr';
+    return null;
+  };
+  let kept = 0;
+  let removed: InflightGcResult['removed'] = [];
+  withFileLockSync(`${path}.lock`, () => {
+    const all = readEntries(path);
+    removed = all.flatMap((entry) => {
+      const reason = classify(entry);
+      return reason === null ? [] : [{ entry, reason }];
+    });
+    kept = all.length - removed.length;
+    if (removed.length === 0) return;
+    writeEntriesAtomic(path, all.filter((entry) => classify(entry) === null));
+  });
+  try {
+    debug.log('pr-tool.inflight', 'gc', { kept, removed: removed.map(({ entry, reason }) => ({ runId: entry.runId, reason })) });
+  } catch { /* fail-soft */ }
+  return { kept, removed };
+}