elanous 0.2.18 → 0.2.20

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

@@ -0,0 +1,258 @@
+/**
+ * RUN-TTL (0.2.21 P1 · first piece · FINDING #24712) — an open harness PR has a «time to landing».
+ *
+ * Open self-impl PRs linger for days while main moves (~80 merges/day), so an old draft rots silently.
+ * Past `tools.selfImplement.runTtlHours` (default 24) since its last commit, the sweep makes one pre-emptive move:
+ *   · live owning run → one resync memo in its control inbox (same path as SIBLING-RESYNC #24893/#24899),
+ *                       at most once per (PR, head sha) — a rebase moves the head and re-arms it
+ *   · no live run     → the registered `elanous:needs-rebase` label, once (QUIET-PR-COMMENTS: never a comment)
+ *
+ * Mode `tools.selfImplement.runTtl.mode`: `shadow` (default) only logs what it would do; `live` writes.
+ * Cost bound: a PR opened inside the TTL is still inside its own time-to-landing and is never fetched
+ * (`freshByCreation`), already-marked PRs without a live run are skipped before any fetch, at most `maxFetch` last-commit lookups per sweep with `concurrency` in flight, and at most `cap` actions.
+ *
+ * Pure core: every side effect is an injected adapter so tests never touch GitHub or the inbox.
+ */
+import { debug } from '../debug/log.js';
+import type { ControlMemoPayload } from '../harness/control-inbox.js';
+import { SIBLING_RESYNC_MARKER_LABEL, type SiblingRunTarget } from './sibling-resync.js';
+
+export const RUN_TTL_CATEGORY = 'self-implement.run-ttl';
+export const RUN_TTL_DEFAULT_HOURS = 24;
+export const RUN_TTL_DEFAULT_CAP = 30;
+export const RUN_TTL_DEFAULT_MAX_FETCH = 60;
+export const RUN_TTL_DEFAULT_CONCURRENCY = 6;
+export const RUN_TTL_MARKER_LABEL = SIBLING_RESYNC_MARKER_LABEL;
+const HARNESS_BRANCH_PREFIX = 'self-impl/';
+const KEEP_LABEL = 'elanous:keep';
+
+export type RunTtlMode = 'shadow' | 'live';
+
+export interface RunTtlCandidate {
+  readonly number: number;
+  readonly branch: string;
+  readonly labels: readonly string[];
+  readonly createdAt: string;
+  readonly headSha: string;
+}
+
+export interface RunTtlAdapters {
+  /** Open PRs against the default branch. A rejection is not an empty list. */
+  listOpenPrs(): Promise<readonly RunTtlCandidate[]>;
+  /** ISO time of the head commit; `undefined` (or a rejection) means unknown and the PR is left alone. */
+  lastCommitAt(pr: RunTtlCandidate): Promise<string | undefined>;
+  resolveRun(pr: RunTtlCandidate): Promise<SiblingRunTarget>;
+  sendMemo(target: { runId: string; spaceId: string }, memo: ControlMemoPayload): Promise<void> | void;
+  addLabel(prNumber: number, label: string): Promise<void> | void;
+  /** Memo dedupe by `<pr>:<headSha>`. Omitted ⇒ no dedupe. */
+  memoSent?(key: string): boolean;
+  recordMemoSent?(key: string): void;
+}
+
+export interface RunTtlResult {
+  readonly mode: RunTtlMode;
+  readonly ttlHours: number;
+  /** Open self-impl PRs considered (keep-labelled excluded). */
+  readonly considered: number;
+  readonly freshByCreation: number;
+  readonly fetched: number;
+  readonly fresh: number;
+  readonly unknown: readonly number[];
+  readonly stale: readonly number[];
+  /** Memo sent (live) or would be sent (shadow). */
+  readonly memo: readonly number[];
+  /** Label added (live) or would be added (shadow). */
+  readonly label: readonly number[];
+  readonly alreadyMarked: readonly number[];
+  readonly alreadyMemoed: readonly number[];
+  /** Owning run lookup failed — left alone (a failed lookup is not a dead run). */
+  readonly unresolved?: readonly number[];
+  readonly skippedOverCap: readonly number[];
+  readonly skippedFetchCap: readonly number[];
+  readonly failed: readonly number[];
+  readonly durationMs: number;
+  readonly reason?: string;
+}
+
+export function runTtlMemo(ageHours: number, ttlHours: number): ControlMemoPayload {
+  return {
+    version: 1,
+    kind: 'run-ttl-resync',
+    urgency: 'normal',
+    body: `[run-ttl] This PR's last commit is ${Math.floor(ageHours)}h old (time-to-landing ${ttlHours}h) while main keeps moving. `
+      + 'Before continuing: git fetch origin main, rebase this branch onto origin/main (resolve conflicts keeping both intents), then re-run the gate on your changed files.',
+  };
+}
+
+async function mapBounded<T, R>(items: readonly T[], limit: number, work: (item: T) => Promise<R>): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await work(items[index]!);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+const nonNegativeInt = (value: number | undefined, fallback: number): number =>
+  value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+
+export async function runRunTtlSweep(input: {
+  adapters: RunTtlAdapters;
+  mode?: RunTtlMode;
+  ttlHours?: number;
+  cap?: number;
+  maxFetch?: number;
+  concurrency?: number;
+  now?: () => number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}): Promise<RunTtlResult> {
+  const { adapters } = input;
+  const now = input.now ?? Date.now;
+  const startedAt = now();
+  const mode: RunTtlMode = input.mode === 'live' ? 'live' : 'shadow';
+  const ttlHours = typeof input.ttlHours === 'number' && Number.isFinite(input.ttlHours) && input.ttlHours > 0
+    ? input.ttlHours : RUN_TTL_DEFAULT_HOURS;
+  const cap = nonNegativeInt(input.cap, RUN_TTL_DEFAULT_CAP);
+  const maxFetch = nonNegativeInt(input.maxFetch, RUN_TTL_DEFAULT_MAX_FETCH);
+  const concurrency = Math.max(1, nonNegativeInt(input.concurrency, RUN_TTL_DEFAULT_CONCURRENCY));
+  const ttlMs = ttlHours * 3_600_000;
+  const log = input.log ?? ((category, event, data) => debug.log(category, event, data));
+  const emit = (event: string, data: Record<string, unknown>) => {
+    try { log(RUN_TTL_CATEGORY, event, { mode, ...data }); } catch { /* fail-soft */ }
+  };
+  let considered = 0;
+  let freshByCreation = 0;
+  let fetched = 0;
+  let fresh = 0;
+  const unknown: number[] = [];
+  const stale: number[] = [];
+  const memo: number[] = [];
+  const label: number[] = [];
+  const alreadyMarked: number[] = [];
+  const alreadyMemoed: number[] = [];
+  const unresolved: number[] = [];
+  const skippedOverCap: number[] = [];
+  const skippedFetchCap: number[] = [];
+  const failed: number[] = [];
+  const result = (reason?: string): RunTtlResult => ({
+    mode, ttlHours, considered, freshByCreation, fetched, fresh, unknown, stale, memo, label, alreadyMarked,
+    alreadyMemoed, unresolved, skippedOverCap, skippedFetchCap, failed, durationMs: Math.max(0, now() - startedAt),
+    ...(reason ? { reason } : {}),
+  });
+  const summary = (out: RunTtlResult): RunTtlResult => {
+    emit('summary', {
+      ttlHours, cap, maxFetch, concurrency, considered, freshByCreation, fetched, fresh,
+      unknown: unknown.length, stale: stale.length, memo: memo.length, label: label.length,
+      alreadyMarked: alreadyMarked.length, alreadyMemoed: alreadyMemoed.length, unresolved: unresolved.length,
+      skippedOverCap: skippedOverCap.length, skippedFetchCap: skippedFetchCap.length, failed: failed.length,
+      memoPrs: memo, labelPrs: label, durationMs: out.durationMs, ...(out.reason ? { reason: out.reason } : {}),
+    });
+    return out;
+  };
+
+  let open: readonly RunTtlCandidate[];
+  try {
+    open = await adapters.listOpenPrs();
+  } catch (error) {
+    emit('skipped', { reason: 'inventory-failed', error: String(error) });
+    return summary(result('inventory-failed'));
+  }
+  const nowMs = now();
+  const pending: { pr: RunTtlCandidate; target: SiblingRunTarget }[] = [];
+  for (const pr of open) {
+    if (!pr.branch.startsWith(HARNESS_BRANCH_PREFIX) || pr.labels.includes(KEEP_LABEL)) continue;
+    considered += 1;
+    const created = Date.parse(pr.createdAt);
+    // A PR opened inside the TTL is inside its own time-to-landing — no fetch needed.
+    if (Number.isFinite(created) && nowMs - created < ttlMs) { freshByCreation += 1; continue; }
+    let target: SiblingRunTarget;
+    try { target = await adapters.resolveRun(pr); } catch (error) {
+      // A failed lookup is not proof the run is gone — never label (or memo) an unresolved PR.
+      unresolved.push(pr.number);
+      emit('run-unresolved', { pr: pr.number, error: String(error) });
+      continue;
+    }
+    // Dead run + marker already present: the quiet signal is in place («once»), nothing to fetch.
+    if (!target.alive && pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+    pending.push({ pr, target });
+  }
+  // Oldest PR first: the most likely to have rotted.
+  pending.sort((a, b) => (Date.parse(a.pr.createdAt) || 0) - (Date.parse(b.pr.createdAt) || 0) || a.pr.number - b.pr.number);
+  const toFetch = pending.slice(0, maxFetch);
+  skippedFetchCap.push(...pending.slice(maxFetch).map(({ pr }) => pr.number));
+  const dated = await mapBounded(toFetch, concurrency, async (entry) => {
+    let at: string | undefined;
+    try { at = await adapters.lastCommitAt(entry.pr); } catch { at = undefined; }
+    fetched += 1;
+    const ms = at ? Date.parse(at) : NaN;
+    return { ...entry, ageMs: Number.isFinite(ms) ? nowMs - ms : undefined };
+  });
+  const stalePrs: (typeof dated[number] & { ageMs: number })[] = [];
+  for (const entry of dated) {
+    if (entry.ageMs === undefined) { unknown.push(entry.pr.number); continue; }
+    if (entry.ageMs < ttlMs) { fresh += 1; continue; }
+    stale.push(entry.pr.number);
+    stalePrs.push({ ...entry, ageMs: entry.ageMs });
+  }
+  stalePrs.sort((a, b) => b.ageMs - a.ageMs || a.pr.number - b.pr.number);
+  let actions = 0;
+  for (const { pr, target, ageMs } of stalePrs) {
+    const ageHours = ageMs / 3_600_000;
+    const key = `${pr.number}:${pr.headSha}`;
+    if (target.alive) {
+      let already: boolean | undefined;
+      try { already = adapters.memoSent?.(key) ?? false; } catch (error) {
+        // Without the journal «once» cannot be proven — skip rather than risk a repeat memo.
+        failed.push(pr.number);
+        emit('memo-journal-failed', { pr: pr.number, stage: 'read', error: String(error) });
+        continue;
+      }
+      if (already) { alreadyMemoed.push(pr.number); continue; }
+    }
+    if (!target.alive && pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+    if (actions >= cap) { skippedOverCap.push(pr.number); continue; }
+    actions += 1;
+    if (target.alive) {
+      if (mode === 'shadow') {
+        memo.push(pr.number);
+        emit('would-memo', { pr: pr.number, runId: target.runId, spaceId: target.spaceId, ageHours: Math.floor(ageHours) });
+        continue;
+      }
+      // Journal first: a memo that cannot be recorded is not sent, so «once per (PR, head sha)» holds.
+      try { adapters.recordMemoSent?.(key); } catch (error) {
+        failed.push(pr.number);
+        emit('memo-journal-failed', { pr: pr.number, stage: 'write', error: String(error) });
+        continue;
+      }
+      try {
+        await adapters.sendMemo({ runId: target.runId, spaceId: target.spaceId }, runTtlMemo(ageHours, ttlHours));
+        memo.push(pr.number);
+        emit('memo', { pr: pr.number, runId: target.runId, spaceId: target.spaceId, ageHours: Math.floor(ageHours) });
+        continue;
+      } catch (error) {
+        // A live run we could not reach still needs to be visible — fall through to the quiet marker.
+        emit('memo-failed', { pr: pr.number, runId: target.runId, error: String(error) });
+        if (pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+      }
+    }
+    const reason = target.alive ? 'memo-failed' : target.reason;
+    if (mode === 'shadow') {
+      label.push(pr.number);
+      emit('would-label', { pr: pr.number, label: RUN_TTL_MARKER_LABEL, reason, ageHours: Math.floor(ageHours) });
+      continue;
+    }
+    try {
+      await adapters.addLabel(pr.number, RUN_TTL_MARKER_LABEL);
+      label.push(pr.number);
+      emit('label', { pr: pr.number, label: RUN_TTL_MARKER_LABEL, reason, ageHours: Math.floor(ageHours) });
+    } catch (error) {
+      failed.push(pr.number);
+      emit('label-failed', { pr: pr.number, error: String(error) });
+    }
+  }
+  return summary(result());
+}

package/src/self-implement/salvage-branches.ts

@@ -0,0 +1,254 @@
+/**
+ * SALVAGE-VISIBLE — Pod 런이 멈추며 남긴 수확 가지(`salvage/<job>/<worktree>`)를 «런 하나 → PR | 수확 가지 | 없음 | 모름» 으로 보인다.
+ *
+ * S: Pod Job 은 자식 rc≠0 이면 워크트리를 `salvage/si-task-<job>/self-impl-…-r<run 16진 앞 6자>` 로 push 한다
+ *    (`src/task-orchestrator/surfaces/self-implement-pod.ts` salvage 단계 · 이름은 `plannedSelfImplBranch` 의 `-r` 접미).
+ * C: 10-07 세 자리가 PR·`salvage-pushed` 로그만 보고 멈춘 Pod 런 여덟을 «수확 0» 으로 읽었다 — 여덟 다 수백 줄짜리 가지가 있었다.
+ * Q: 런 id 하나로 그 가지를 «한 번의 목록»에서 찾고, 크기를 재고, 못 읽었을 때 «없음» 이라 말하지 않으려면?
+ * A: `git ls-remote origin 'refs/heads/salvage/*'` 한 번 → `-r<6>` 접미로 Job 을 고르고, 같은 Job 의 형제(`/repo`·`-early`)까지
+ *    numstat 로 재서 `.gitignore`·`docs/goals/**` 만 건드린 가지는 버린다. 목록 실패는 `unknown` 이다(⛔ `none` 이 아니다).
+ *
+ * 순수 모듈 — git 은 주입된 러너로만 부른다(시험은 네트워크 0).
+ */
+import { runGitCommand } from '../git-fs/runner.js';
+
+export interface SalvageGitResult {
+  status: number | null;
+  stdout: string;
+  stderr: string;
+}
+
+export type SalvageGitRunner = (args: string[]) => SalvageGitResult;
+
+export interface SalvageDiffstat {
+  files: number;
+  insertions: number;
+  deletions: number;
+}
+
+export interface SalvageBranch {
+  branch: string;
+  sha: string;
+  diffstat: SalvageDiffstat;
+}
+
+export type SalvageLookup =
+  | { status: 'found'; branches: SalvageBranch[] }
+  | { status: 'none'; trivialSkipped: number }
+  | { status: 'unknown'; reason: string }
+  /** PR 이 이겨서 가지를 «조회하지 않았다» — ⛔ 부재(`none`)가 아니다. */
+  | { status: 'not-checked' };
+
+export interface RemoteSalvageRef {
+  branch: string;
+  sha: string;
+}
+
+const SALVAGE_REF_PREFIX = 'refs/heads/';
+
+/** `run-bfe2b5c1-…` → `bfe2b5` — `plannedSelfImplBranch` 의 `-r` 접미와 같은 규칙. 6자가 안 되면 null(⛔ 짧은 접두는 남의 가지를 문다). */
+export function runSuffixKey(runId: string): string | null {
+  // `run-` 뒤에 «연속된» 16진 6자가 있어야 한다 — 구분자를 지우고 이어 붙이면 `run-ab-cdef` 가 남의 `abcdef` 를 문다.
+  const m = /^(?:run-)?([0-9a-f]{6})/i.exec(runId.trim());
+  return m ? m[1]!.toLowerCase() : null;
+}
+
+/** `git ls-remote` 출력 → `{ branch, sha }`. salvage/ 가 아닌 «올바른» 줄은 버리고, 형식이 깨진 비어 있지 않은 줄은 `unparsed` 로 센다
+ *  (⛔ rc=0 ⊕ 못 읽은 출력을 «없음» 으로 접지 않는다). */
+export function parseLsRemote(stdout: string): RemoteSalvageRef[] & { unparsed?: number } {
+  const rows: RemoteSalvageRef[] & { unparsed?: number } = [];
+  let unparsed = 0;
+  const lines = stdout.split(/\r?\n/);
+  if (lines.at(-1) === '') lines.pop();
+  for (const line of lines) {
+    // 공백만 있는 줄도 «못 읽은 줄» 이다(⛔ 건너뛰면 깨진 목록이 «없음» 이 된다).
+    const m = /^([0-9a-f]{40}|[0-9a-f]{64})\t(refs\/\S+)$/i.exec(line);
+    if (!m) {
+      unparsed += 1;
+      continue;
+    }
+    if (!m[2]!.startsWith(`${SALVAGE_REF_PREFIX}salvage/`)) continue;
+    rows.push({ sha: m[1]!.toLowerCase(), branch: m[2]!.slice(SALVAGE_REF_PREFIX.length) });
+  }
+  if (unparsed > 0) rows.unparsed = unparsed;
+  return rows;
+}
+
+/** 워크트리 조각(마지막 경로 성분)이 `-r<key>` 또는 `-r<key>-early` 로 끝나는가. */
+export function branchMatchesRun(branch: string, key: string): boolean {
+  const leaf = branch.slice(branch.lastIndexOf('/') + 1).toLowerCase();
+  return leaf.endsWith(`-r${key}`) || leaf.endsWith(`-r${key}-early`);
+}
+
+function jobDir(branch: string): string {
+  return branch.slice(0, branch.lastIndexOf('/'));
+}
+
+/** 런 하나에 속하는 원격 가지 — `-r<key>` 로 맞은 Job 디렉토리의 형제 전부(`/repo` 포함). */
+export function selectRunSalvageRefs(refs: readonly RemoteSalvageRef[], key: string): RemoteSalvageRef[] {
+  const jobs = new Set(refs.filter((ref) => branchMatchesRun(ref.branch, key)).map((ref) => jobDir(ref.branch)));
+  return refs.filter((ref) => jobs.has(jobDir(ref.branch)));
+}
+
+/** 루트 `.gitignore`·`docs/goals/**` 만 바꾼 가지는 «수확할 일» 이 아니다(Pod 가 `/repo` 에 골 문서만 남긴다). */
+export function isTrivialSalvagePath(path: string): boolean {
+  // ⛔ trim 하지 않는다 — `-z` 경로는 원 바이트이고 ` .gitignore` 는 다른 파일이다.
+  return path === '.gitignore' || path.startsWith('docs/goals/');
+}
+
+/** `git diff --numstat -z --no-renames` → diffstat ⊕ 경로. 레코드는 NUL 로 끊기고 경로는 따옴표 없이 «원 바이트» 그대로다
+ *  (⛔ `-z` 없이는 한글·특수문자 경로가 `"docs/goals/\355…"` 로 감싸져 제외 규칙을 못 탄다). 바이너리(`-`)는 줄 수 0. */
+export function parseNumstat(stdout: string): { diffstat: SalvageDiffstat; paths: string[]; unparsed: number } {
+  const paths: string[] = [];
+  let insertions = 0;
+  let deletions = 0;
+  let unparsed = 0;
+  const records = stdout.split('\0');
+  // `-z` 출력은 레코드마다 NUL 로 «끝난다» — 마지막 조각이 비어 있지 않으면 잘린 출력이다(⛔ 정상 레코드로 받지 않는다).
+  const tail = records.pop() ?? '';
+  if (tail !== '') unparsed += 1;
+  for (const record of records) {
+    if (record === '') {
+      unparsed += 1;
+      continue;
+    }
+    const m = /^(\d+|-)\t(\d+|-)\t([^\0]+)$/.exec(record.replace(/^\n+/, ''));
+    if (!m) {
+      unparsed += 1;
+      continue;
+    }
+    insertions += m[1] === '-' ? 0 : Number(m[1]);
+    deletions += m[2] === '-' ? 0 : Number(m[2]);
+    paths.push(m[3]!);
+  }
+  return { diffstat: { files: paths.length, insertions, deletions }, paths, unparsed };
+}
+
+/** 러너가 «던져도» 결과로 접는다 — 실행 예외는 rc=null ⊕ 메시지(호출부가 `unknown` 으로 옮긴다). */
+function runSafely(git: SalvageGitRunner, args: string[]): SalvageGitResult {
+  try {
+    return git(args);
+  } catch (error) {
+    return { status: null, stdout: '', stderr: `threw: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+
+function failureReason(step: string, result: SalvageGitResult): string {
+  const tail = result.stderr.trim().split(/\r?\n/).at(-1) ?? '';
+  return `${step} rc=${result.status ?? 'signal'}${tail ? ` · ${tail.slice(0, 160)}` : ''}`;
+}
+
+export interface FindSalvageOptions {
+  /** 이미 읽은 ls-remote 목록(여러 런을 한 번의 목록으로). 없으면 러너로 한 번 읽는다. */
+  listing?: RemoteSalvageRef[] | { error: string };
+}
+
+/** 비교 기준 — fetch 가 함께 갱신하는 `origin/main` 하나로 고정한다(다른 기준은 fetch 와 어긋난다). */
+const SALVAGE_DIFF_BASE = 'origin/main';
+
+/** `git ls-remote origin 'refs/heads/salvage/*'` 한 번. 실패는 `{ error }` — 호출부가 `unknown` 으로 옮긴다. */
+export function listRemoteSalvageRefs(git: SalvageGitRunner): RemoteSalvageRef[] | { error: string } {
+  const result = runSafely(git, ['ls-remote', 'origin', 'refs/heads/salvage/*']);
+  if (result.status !== 0) return { error: failureReason('ls-remote', result) };
+  const rows = parseLsRemote(result.stdout);
+  if (rows.unparsed) return { error: `ls-remote 출력 ${rows.unparsed}줄을 못 읽음` };
+  return rows;
+}
+
+/** 런 id → 그 런의 수확 가지. 목록·fetch·diff 중 하나라도 못 읽으면 `unknown`(⛔ `none` 으로 접지 않는다). */
+export function findRunSalvageBranches(runId: string, git: SalvageGitRunner, options: FindSalvageOptions = {}): SalvageLookup {
+  const key = runSuffixKey(runId);
+  if (key === null) return { status: 'unknown', reason: `런 id 에서 16진 6자를 못 뽑았다 (${runId})` };
+  const listing = options.listing ?? listRemoteSalvageRefs(git);
+  if (!Array.isArray(listing)) return { status: 'unknown', reason: listing.error };
+  const refs = selectRunSalvageRefs(listing, key);
+  if (refs.length === 0) return { status: 'none', trivialSkipped: 0 };
+  const fetched = runSafely(git, ['fetch', '--no-tags', '--quiet', 'origin', 'main', ...refs.map((ref) => `${SALVAGE_REF_PREFIX}${ref.branch}`)]);
+  if (fetched.status !== 0) return { status: 'unknown', reason: failureReason('fetch', fetched) };
+  const branches: SalvageBranch[] = [];
+  let trivialSkipped = 0;
+  for (const ref of refs) {
+    const diff = runSafely(git, ['diff', '--numstat', '-z', '--no-renames', `${SALVAGE_DIFF_BASE}...${ref.sha}`]);
+    if (diff.status !== 0) return { status: 'unknown', reason: failureReason(`diff ${ref.branch}`, diff) };
+    const { diffstat, paths, unparsed } = parseNumstat(diff.stdout);
+    if (unparsed > 0) return { status: 'unknown', reason: `diff ${ref.branch} 출력 ${unparsed}줄을 못 읽음` };
+    if (paths.every(isTrivialSalvagePath)) {
+      trivialSkipped += 1;
+      continue;
+    }
+    branches.push({ branch: ref.branch, sha: ref.sha, diffstat });
+  }
+  branches.sort((a, b) => b.diffstat.insertions + b.diffstat.deletions - (a.diffstat.insertions + a.diffstat.deletions));
+  return branches.length > 0 ? { status: 'found', branches } : { status: 'none', trivialSkipped };
+}
+
+/** 실물 러너 — 공용 git 심(`runGitCommand` · 락 재시도) 위에서 cwd 를 «인자로» 받는다. */
+export function gitSalvageRunner(cwd: string): SalvageGitRunner {
+  return (args) => {
+    const result = runGitCommand(cwd, args, { encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+    return { status: result.status, stdout: result.stdout, stderr: result.stderr };
+  };
+}
+
+export type RunPrState =
+  | { status: 'pr'; number: number }
+  | { status: 'none' }
+  | { status: 'unknown'; reason: string };
+
+export type RunSalvageOutcome = 'pr' | 'salvage' | 'none' | 'unknown';
+
+export interface RunSalvageVerdict {
+  runId: string;
+  outcome: RunSalvageOutcome;
+  pr: RunPrState;
+  salvage: SalvageLookup;
+  line: string;
+}
+
+function branchLine(branch: SalvageBranch): string {
+  return `수확 가지 ${branch.branch} (+${branch.diffstat.insertions}/-${branch.diffstat.deletions} · ${branch.diffstat.files} files)`;
+}
+
+/** 판정 — PR 이 있으면 PR 이 이긴다. 없으면 수확 가지 → 없음 → 모름 순. PR 을 못 읽었으면 «PR 모름» 을 같이 단다. */
+export function decideRunSalvage(runId: string, pr: RunPrState, salvage: SalvageLookup): RunSalvageVerdict {
+  const prNote = pr.status === 'unknown' ? ` · PR 모름(${pr.reason})` : '';
+  if (pr.status === 'pr') return { runId, outcome: 'pr', pr, salvage, line: `${runId}  PR #${pr.number}` };
+  if (salvage.status === 'found') {
+    const [first, ...rest] = salvage.branches;
+    const more = rest.length > 0 ? ` ⊕ 가지 ${rest.length}개 더` : '';
+    return { runId, outcome: 'salvage', pr, salvage, line: `${runId}  ${branchLine(first!)}${more}${prNote}` };
+  }
+  if (salvage.status === 'not-checked') return { runId, outcome: 'unknown', pr, salvage, line: `${runId}  모름(수확 가지 미조회)${prNote}` };
+  if (salvage.status === 'unknown') return { runId, outcome: 'unknown', pr, salvage, line: `${runId}  모름(${salvage.reason})${prNote}` };
+  const skipped = salvage.trivialSkipped > 0 ? ` (골 문서·.gitignore 만 있는 가지 ${salvage.trivialSkipped}개 제외)` : '';
+  // PR 을 못 읽었으면 «없음» 이라 단정하지 않는다.
+  if (pr.status === 'unknown') return { runId, outcome: 'unknown', pr, salvage, line: `${runId}  모름(수확 가지 없음${skipped} · PR 모름 — ${pr.reason})` };
+  return { runId, outcome: 'none', pr, salvage, line: `${runId}  없음${skipped}` };
+}
+
+/** 원장 항목 → PR 상태. 마지막 `pr-opened` 의 번호(없으면 `run-rollup.prNumber`).
+ *  ⛔ 번호가 없다고 곧 «PR 없음» 이 아니다 — 원장이 «종료(`run-status`)» 를 PR 아닌 단계로 적었을 때만 `none`.
+ *  원장 파일이 없거나(호스트가 모르는 Pod 런) 종료 기록이 없거나 종료가 PR 단계인데 번호가 없으면 `unknown`. */
+export function prStateFromLedger(entries: ReadonlyArray<{ event: string; data: Record<string, unknown> }> | null): RunPrState {
+  if (entries === null) return { status: 'unknown', reason: '호스트 원장 없음' };
+  const pick = (value: unknown): number | null => (typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : null);
+  const prNumberOf = (data: Record<string, unknown>): number | null => pick(data.number) ?? pick(data.prNumber)
+    ?? (typeof data.prUrl === 'string' ? pick(Number(/\/pull\/(\d+)/.exec(data.prUrl)?.[1])) : null);
+  const openedEntries = entries.filter((entry) => entry.event === 'pr-opened');
+  const opened = openedEntries.at(-1)?.data;
+  // 번호 «있는» 마지막 pr-opened — 뒤에 번호 없는 기록이 와도 알려진 PR 을 버리지 않는다.
+  const number = openedEntries.map((entry) => prNumberOf(entry.data)).filter((n): n is number => n !== null).at(-1)
+    ?? pick(entries.filter((entry) => entry.event === 'run-rollup').at(-1)?.data.prNumber) ?? null;
+  if (number !== null) return { status: 'pr', number };
+  if (opened !== undefined) return { status: 'unknown', reason: '원장에 pr-opened 가 있으나 번호 없음' };
+  const terminal = entries.filter((entry) => entry.event === 'run-status').at(-1)?.data.stage;
+  if (typeof terminal !== 'string') return { status: 'unknown', reason: '원장에 PR·종료 기록 없음' };
+  if (!NO_PR_TERMINAL_STAGES.has(terminal)) return { status: 'unknown', reason: `마지막 단계 ${terminal} — PR 없는 종료로 확인 안 됨` };
+  return { status: 'none' };
+}
+
+/** PR 을 열기 «전에» 끝나는 종료 단계(`run-status-mapping.ts` `SelfImplementStage` 중). ⛔ merged·pr-opened·merge-ready·merge-conflict 는
+ *  PR 이 있었을 단계라 빠진다 — 그 단계인데 번호가 없으면 `unknown`. 진행 중 단계도 여기 없으므로 `unknown`. */
+const NO_PR_TERMINAL_STAGES: ReadonlySet<string> = new Set([
+  'worktree-completed', 'gate-failed', 'review-blocked', 'no-changes', 'aborted', 'timed-out', 'pr-declined', 'soft-stopped', 'parked',
+]);

package/src/self-implement/salvage-retention.ts

@@ -0,0 +1,123 @@
+/**
+ * SALVAGE-RETENTION (RFC-draft-pr-accumulation-root-fix R1 다음 조각) — 원격 `salvage/*` 가지의 보존 규칙.
+ *
+ * S: DRAFT-NOT-ARCHIVE 로 멈춘 런은 PR 대신 수확 가지를 남긴다. 가지는 이미 1,000개를 넘었다.
+ * C: 가지가 지워지지 않고 쌓이면 draft 재고가 «수확 가지 재고»로 옮겨 갈 뿐이다.
+ * Q: 어느 가지를 지워도 되나?
+ * A: 14일보다 오래됐고, 열린 PR 도(head·본문) 카드도(런 키·본문) 가리키지 않는 가지. 지금은 «그림자»로 수만 낸다.
+ *    `tools.selfImplement.salvageRetention.mode` = 'shadow'(기본) | 'live'. ⛔ 이 조각은 live 여도 지우지 않는다(다음 조각).
+ *
+ * 순수 판정 + 주입된 조회. ⛔ 나이를 못 읽은 가지는 «오래됨»으로 세지 않는다(`unknownAge`).
+ */
+import { execFileSync } from 'node:child_process';
+import { branchMatchesRun, runSuffixKey } from './salvage-branches.js';
+
+export type SalvageRetentionMode = 'shadow' | 'live';
+export const SALVAGE_RETENTION_MAX_AGE_DAYS = 14;
+
+export interface DatedSalvageRef {
+  readonly branch: string;
+  readonly committedAt: string | null;
+}
+
+export interface SalvageReferenceSources {
+  /** 열린 PR — head 가지 ⊕ 본문(본문에 가지 이름이 적혀 있으면 참조로 센다). */
+  readonly openPrs: ReadonlyArray<{ number: number; headRefName: string; body?: string | null }>;
+  /** 과제 카드 — 런 id(가지의 `-r<6hex>` 와 맞추기) ⊕ 카드 직렬화 본문. */
+  readonly cards: ReadonlyArray<{ id: string; runId?: string; text: string }>;
+}
+
+export interface SalvageRetentionReport {
+  readonly mode: SalvageRetentionMode;
+  readonly maxAgeDays: number;
+  readonly total: number;
+  readonly older: number;
+  readonly unknownAge: number;
+  readonly referenced: number;
+  /** 지울 후보 — 오래됐고 참조 0. 그림자에서는 수만 보고한다. */
+  readonly candidates: number;
+  readonly sample: readonly string[];
+  readonly deleted: 0;
+}
+
+/** 가지를 가리키는 것이 있나 — 열린 PR head/본문 · 카드 런 키/본문. */
+export function salvageBranchReferenced(branch: string, sources: SalvageReferenceSources): boolean {
+  if (sources.openPrs.some((pr) => pr.headRefName === branch || (pr.body ?? '').includes(branch))) return true;
+  return sources.cards.some((card) => {
+    if (card.text.includes(branch)) return true;
+    const key = card.runId ? runSuffixKey(card.runId) : null;
+    return key !== null && branchMatchesRun(branch, key);
+  });
+}
+
+export function classifySalvageRetention(input: {
+  refs: readonly DatedSalvageRef[];
+  sources: SalvageReferenceSources;
+  now: Date;
+  mode: SalvageRetentionMode;
+  maxAgeDays?: number;
+}): SalvageRetentionReport {
+  const maxAgeDays = input.maxAgeDays ?? SALVAGE_RETENTION_MAX_AGE_DAYS;
+  const cutoff = input.now.getTime() - maxAgeDays * 86_400_000;
+  let older = 0;
+  let unknownAge = 0;
+  let referenced = 0;
+  const candidates: string[] = [];
+  for (const ref of input.refs) {
+    const at = ref.committedAt ? Date.parse(ref.committedAt) : NaN;
+    if (!Number.isFinite(at)) { unknownAge += 1; continue; }
+    if (at >= cutoff) continue;
+    older += 1;
+    if (salvageBranchReferenced(ref.branch, input.sources)) { referenced += 1; continue; }
+    candidates.push(ref.branch);
+  }
+  return { mode: input.mode, maxAgeDays, total: input.refs.length, older, unknownAge, referenced, candidates: candidates.length, sample: candidates.slice(0, 5), deleted: 0 };
+}
+
+export function formatSalvageRetention(report: SalvageRetentionReport): string {
+  return `수확 가지 보존(${report.mode}): 전체 ${report.total} · ${report.maxAgeDays}일 초과 ${report.older} · 그중 참조 있음 ${report.referenced} · 지울 후보(참조 0) ${report.candidates}`
+    + `${report.unknownAge ? ` · 나이 모름 ${report.unknownAge}` : ''} · 지운 것 0${report.mode === 'live' ? '(live 삭제는 다음 조각)' : ''}`;
+}
+
+type GhExecute = (args: string[]) => string;
+const executeGh: GhExecute = (args) => execFileSync('gh', args, {
+  encoding: 'utf8', timeout: 60_000, maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], env: process.env,
+});
+
+const REFS_QUERY = `query($owner:String!,$name:String!,$after:String){repository(owner:$owner,name:$name){refs(refPrefix:"refs/heads/salvage/",first:100,after:$after){pageInfo{hasNextPage endCursor} nodes{name target{... on Commit{committedDate}}}}}}`;
+
+/** GitHub GraphQL 로 `salvage/*` 가지 ⊕ 마지막 커밋 시각(100개씩). ⛔ 페이지가 깨지면 던진다(부분 목록을 «전체»로 읽지 않는다). */
+export function listDatedSalvageRefs(repository: string, execute: GhExecute = executeGh): DatedSalvageRef[] {
+  const [owner, name] = repository.split('/');
+  if (!owner || !name) throw new Error(`repository must be owner/name: ${repository}`);
+  const refs: DatedSalvageRef[] = [];
+  let after: string | null = null;
+  for (let page = 0; page < 200; page++) {
+    const args = ['api', 'graphql', '-f', `query=${REFS_QUERY}`, '-F', `owner=${owner}`, '-F', `name=${name}`, ...(after ? ['-F', `after=${after}`] : [])];
+    const parsed = JSON.parse(execute(args)) as { data?: { repository?: { refs?: { pageInfo?: { hasNextPage?: boolean; endCursor?: string | null }; nodes?: Array<{ name?: unknown; target?: { committedDate?: unknown } | null }> } } } };
+    const block = parsed.data?.repository?.refs;
+    if (!block || !Array.isArray(block.nodes) || !block.pageInfo) throw new Error('incomplete salvage ref listing');
+    for (const node of block.nodes) {
+      if (typeof node.name !== 'string') throw new Error('incomplete salvage ref listing');
+      refs.push({ branch: `salvage/${node.name}`, committedAt: typeof node.target?.committedDate === 'string' ? node.target.committedDate : null });
+    }
+    if (!block.pageInfo.hasNextPage) return refs;
+    after = block.pageInfo.endCursor ?? null;
+    if (!after) throw new Error('incomplete salvage ref listing');
+  }
+  throw new Error('salvage ref listing exceeded pagination limit');
+}
+
+const OPEN_PR_LIMIT = 5000;
+
+/** 열린 PR(head ⊕ 본문). ⛔ 상한에 닿으면 «전부 읽었다»를 증명 못 하므로 던진다(참조 있는 가지를 후보로 세지 않는다). */
+export function listOpenPrRefs(repository: string, execute: GhExecute = executeGh): SalvageReferenceSources['openPrs'] {
+  const rows = JSON.parse(execute(['pr', 'list', '--repo', repository, '--state', 'open', '--limit', String(OPEN_PR_LIMIT), '--json', 'number,headRefName,body'])) as unknown;
+  if (!Array.isArray(rows)) throw new Error('incomplete open PR listing');
+  if (rows.length >= OPEN_PR_LIMIT) throw new Error(`incomplete open PR listing: reached the ${OPEN_PR_LIMIT} limit`);
+  return rows.map((row) => {
+    const pr = row as { number?: unknown; headRefName?: unknown; body?: unknown };
+    if (typeof pr.number !== 'number' || typeof pr.headRefName !== 'string') throw new Error('incomplete open PR listing');
+    return { number: pr.number, headRefName: pr.headRefName, body: typeof pr.body === 'string' ? pr.body : null };
+  });
+}

package/src/self-implement/seams.ts

@@ -1423,6 +1423,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       const { supersedeMergedGoalDrafts } = await import('../harness/harness-cli-command.js');
       await supersedeMergedGoalDrafts(number, cwd);
     },
+    resyncSiblingsOnMerge: async (number, cwd) => {
+      const { resyncMergedSiblings } = await import('../harness/harness-cli-command.js');
+      await resyncMergedSiblings(number, cwd);
+    },
     followUp: {
       mode: readFollowUpMode(),
       stateRoot: elanousStateRoot(),

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

@@ -111,6 +111,8 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.harvestable === true && r.branch ? { harvestable: true } : {}),
     ...(r.worktreePath ? { worktreePath: r.worktreePath } : {}),
     ...(r.prUrl ? { prUrl: r.prUrl } : {}),
+    // TA-LIVE-REVIEW-POD — 작업 트리 없는 런(Pod)의 live review 가 «런이 낸 PR 머리»를 확인하는 근거.
+    ...(r.checkedHeadCommit !== undefined ? { checkedHeadCommit: r.checkedHeadCommit } : {}),
     ...(r.merged !== undefined ? { merged: r.merged } : {}),
     ...(r.mergeReason ? { mergeReason: r.mergeReason } : {}),
     ...(r.completionDisposition ? { completionDisposition: r.completionDisposition } : {}),