elanous 0.2.10 → 0.2.12

package/src/seat-loop/seat-report.ts

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
-import { seatDay, seatLedgerPath, type SeatEntry } from './seat-loop.js';
+import { seatDay, seatLedgerPath, type OpCandidate, type SeatEntry } from './seat-loop.js';
 
 export type SeatReportDeps = {
   root?: string;
@@ -21,6 +21,21 @@ export type SeatReportResult = { seat: string; date: string; body: string; poste
 const repoRoot = resolve(import.meta.dir, '../..');
 const exec = promisify(execFile);
 
+function opJudgment(candidate: OpCandidate): { kind: 'card' | 'todo'; text: string } | null {
+  if (candidate.kind === 'release-readiness') {
+    if (candidate.verdict === 'no-open-release') return null;
+    return { kind: 'todo', text: `판올림 준비 ${candidate.version} · ${candidate.verdict} · 빨강 ${candidate.red.join(', ') || '없음'} · 미결 ${candidate.undecided.join(', ') || '없음'} · 차단 ${candidate.blocked.join(', ') || '없음'}` };
+  }
+  if (candidate.kind === 'unassigned-cell') {
+    if (candidate.verdict === 'none' || !candidate.id) return null;
+    return { kind: 'todo', text: `빈 칸 분배 ${candidate.version} ${candidate.id} ${candidate.title ?? ''}`.trim() };
+  }
+  if (candidate.verdict === 'none' || !candidate.id) return null;
+  const text = `결정 대리 ${candidate.id} ${candidate.title ?? ''}`.trim();
+  return { kind: candidate.category && ['irreversible', 'money', 'security', 'secret', 'publish'].includes(candidate.category) ? 'card' : 'todo',
+    text: `${text} (${candidate.category ?? '범주 없음'})` };
+}
+
 async function defaultSend(body: string, seat: string, pr: number, repo: string): Promise<void> {
   const dir = mkdtempSync(join(tmpdir(), 'seat-report-'));
   try {
@@ -42,7 +57,25 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
   const entries = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line) as SeatEntry);
   // One line per item, its last state wins: an `attempting` row followed by `launched` is not «unconfirmed».
   const latest = new Map<string, SeatEntry>();
+  const judgments = new Map<string, OpCandidate>();
   for (const entry of entries) {
+    if (seat === 'OP' && entry.candidate) {
+      if (entry.candidate.verdict === 'none') {
+        if (entry.candidate.id) {
+          const key = entry.candidate.kind === 'unassigned-cell'
+            ? `unassigned-cell:${JSON.stringify([entry.candidate.version, entry.candidate.id])}`
+            : `decision-delegation:${entry.candidate.id}`;
+          judgments.delete(key);
+        } else for (const key of judgments.keys()) if (key.startsWith(`${entry.candidate.kind}:`)) judgments.delete(key);
+        continue;
+      }
+      const key = entry.candidate.kind === 'unassigned-cell'
+        ? `unassigned-cell:${JSON.stringify([entry.candidate.version, entry.candidate.id])}`
+        : entry.candidate.kind === 'decision-delegation' && entry.candidate.id
+          ? `${entry.candidate.kind}:${entry.candidate.id}` : entry.candidate.kind;
+      judgments.set(key, entry.candidate);
+      continue;
+    }
     const key = entry.item ? `${entry.item.source}:${entry.item.version ?? ''}:${entry.item.id}` : `none:${entry.status}`;
     latest.delete(key);
     latest.set(key, entry);
@@ -55,7 +88,9 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
     if (entry.status === 'attempting' || entry.status === 'outcome-unknown') return `결과 확인 필요 ${entry.status} ${label}`;
     return `건너뜀 ${entry.status} ${label}`;
   });
-  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || '원장 기록 없음'}`;
+  const classified = [...judgments.values()].map(opJudgment).filter((row): row is NonNullable<typeof row> => row !== null);
+  const opDetail = classified.length ? ` · 결정 카드 후보: ${classified.filter((row) => row.kind === 'card').map((row) => row.text).join(' / ') || '없음'} · OP 가 할 일: ${classified.filter((row) => row.kind === 'todo').map((row) => row.text).join(' / ') || '없음'}` : '';
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}`;
   const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
   const posted = deps.post === true && pr !== undefined;
   if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);

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

@@ -97,6 +97,8 @@ export interface DevCliOpts {
   pollMs?: string;
   model?: string;
   attach?: string;
+  /** drive: DRIVE-JAIL boundary directory. */
+  jailHome?: string;
   observeOnly?: boolean;
   cols?: string;
   rows?: string;
@@ -1748,7 +1750,7 @@ export function assertDevCliPathOptions(
   if (foreign.length > 0) throw new DevPipelineError(formatForeignDevOptions(path, foreign));
 }
 
-const DRIVE_ALIAS_OPTIONS = new Set(['goal', 'maxSteps', 'pollMs', 'model', 'cwd', 'worktree', 'json', 'attach']);
+const DRIVE_ALIAS_OPTIONS = new Set(['goal', 'maxSteps', 'pollMs', 'model', 'cwd', 'worktree', 'json', 'attach', 'jailHome']);
 const DRIVE_ALIAS_ALLOWED_FLAGS = [...DRIVE_ALIAS_OPTIONS].map(toCliFlag).join(' · ');
 
 export function assertDriveAliasOptions(explicitOptionNames: readonly string[]): void {
@@ -1947,6 +1949,7 @@ export function buildDevCliSpec(
         ...(opts.pollMs !== undefined ? { pollMs: parseNonNegativeInt(opts.pollMs, '--poll-ms') } : {}),
         ...(opts.model ? { model: opts.model } : {}),
         ...(opts.cwd ? { cwd: opts.cwd } : {}),
+        ...(opts.jailHome ? { jailHome: opts.jailHome } : {}),
       },
     };
   }

package/src/self-dev/dev-pipeline.ts

@@ -25,6 +25,7 @@ import { createRepositoryReferencedFileReader, type ReferencedFileReader } from
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
 import { debug } from '../debug/log.js';
+import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import type { GitRunResult } from '../git-fs/retry.js';
 import { DEFAULT_BRANCH_WORKTREE_BASE, observeGitResidue, type GitResidueObservation } from '../git-fs/worktree.js';
@@ -135,6 +136,8 @@ export interface DevShellDriveOpts {
   pollMs?: number;
   model?: string;
   cwd?: string;
+  /** DRIVE-JAIL boundary — inputs naming paths outside it are not sent to the PTY. */
+  jailHome?: string;
 }
 
 /** staged harness(plan-staged) 실행 옵션 — `harness run` front door의 무손실 재라우팅용.
@@ -1852,6 +1855,24 @@ async function observeDevTaskDispatch(spec: DevPipelineSpec, plan: ResolvedDevPl
   }
 }
 
+async function inspectReleasePathBeforeMerge(seams: SelfImplementSeams, number: number, cwd: string): Promise<string | undefined> {
+  if (!seams.readPrFiles) throw new Error('release-path inspection unavailable — automatic merge refused');
+  const files = await seams.readPrFiles({ number, cwd });
+  if (!Array.isArray(files) || !files.every((path) => typeof path === 'string')) throw new Error('invalid PR file list — automatic merge refused');
+  const path = releasePathHold(files);
+  if (!path) return undefined;
+  debug.log('self-dev.merge', 'release-path-hold', { number, path, label: RELEASE_PATH_LABEL });
+  try {
+    if (!seams.addPrLabel) throw new Error('addPrLabel seam unavailable');
+    await seams.addPrLabel({ number, label: RELEASE_PATH_LABEL, cwd });
+  } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number, path, action: 'label', error: String(error) }); }
+  try {
+    if (!seams.postPrComment) throw new Error('postPrComment seam unavailable');
+    await seams.postPrComment({ number, body: releasePathHoldComment(path), cwd });
+  } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number, path, action: 'comment', error: String(error) }); }
+  return path;
+}
+
 async function runDevPipelineDispatch(
   spec: DevPipelineSpec,
   deps: DevPipelineDeps,
@@ -2071,7 +2092,22 @@ async function runDevPipelineDispatch(
     const defaultSeams = deps.buildSelfImplementSeams
       ? await deps.buildSelfImplementSeams(plan)
       : await buildDefaultSelfImplementSeams(plan, { progress: deps.progress });
-    const seams = deps.approver ? { ...defaultSeams, approvePr: deps.approver } : defaultSeams;
+    const assembledSeams = deps.approver ? { ...defaultSeams, approvePr: deps.approver } : defaultSeams;
+    // Guard even injected runSelfImplement implementations: do not trust a dispatched merge to
+    // have used orchestrator's own PR-path check before requesting mergePr.
+    const seams: SelfImplementSeams = {
+      ...assembledSeams,
+      ...(assembledSeams.mergePr ? { mergePr: async (input) => {
+        let path: string | undefined;
+        try { path = await inspectReleasePathBeforeMerge(assembledSeams, input.number, input.cwd); }
+        catch (error) {
+          debug.log('self-dev.merge', 'release-path-inspection-failed', { number: input.number, error: String(error) });
+          return { merged: false, detail: `automatic merge refused: ${String(error)}` };
+        }
+        if (path) return { merged: false, detail: `OP approval required: ${path}` };
+        return assembledSeams.mergePr!(input);
+      } } : {}),
+    };
     // ⭐ 대표 지시(2026-09-08) — ***걸음을 「위」로 흘린다.***
     //   🩸 그 전까지 런 슈퍼바이저가 받는 것은 «시도의 요약 판정»뿐이었고(stage·stopReason·분류 …)
     //     「어느 노드를 몇 번 밟았나」는 ***런 안에서 끝났다***(`onNodeEntry` 는 있는데 호출부 0).

package/src/self-dev/draft-sweep.ts

@@ -1,11 +1,12 @@
-import { CLAIM_IDLE_HOURS, PR_LABELS } from '../github/pr-labels.js';
+import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+import { debug } from '../debug/log.js';
 import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
   readonly labels: readonly string[];
   readonly createdAt: string;
-  /** Last PR update (push, label, comment). Missing ⇒ running claim stays untouched; other drafts use legacy triage. */
+  /** Last PR update (push, label, comment). Missing ⇒ no idle-based close; merged twins can still close. */
   readonly updatedAt?: string;
   readonly runId?: string | null;
 }
@@ -18,7 +19,7 @@ export interface DraftSweepAdapters {
   /** Each call returns one complete page; a rejection must not be mistaken for an empty page. */
   listDrafts(page: number, perPage: number, repository: string): Promise<readonly SweepDraft[]>;
   listMerged(page: number, perPage: number, repository: string): Promise<readonly SweepMergedPr[]>;
-  /** Undefined means no run assessment; it does not authorize a close. */
+  /** Undefined means no run assessment; a merged twin or 24h idle draft can still authorize a close. */
   getRunStatus(draft: SweepDraft, repository: string): Promise<string | undefined>;
   /** Undefined means liveness could not be established. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
@@ -26,6 +27,10 @@ export interface DraftSweepAdapters {
   closeDraft(repository: string, number: number, comment: string): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
+  /** Whether the current owned run has a self-implement.result final observation, even if its worktree remains. */
+  hasFinalRunResult?(draft: SweepDraft, repository: string): Promise<boolean | undefined>;
+  /** Per-file last change on the draft branch; undefined means file coverage is unverified. */
+  getLatestFileChanges?(draft: SweepDraft, repository: string): Promise<Readonly<Record<string, string>> | undefined>;
 }
 
 export interface DraftSweepOptions {
@@ -51,6 +56,7 @@ export interface DraftSweepResult {
   apply: boolean;
   complete: boolean;
   entries: DraftSweepEntry[];
+  counts: Record<string, number>;
   /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
   unobserved?: number;
   /** Closes decided this tick (at most DRAFT_SWEEP_CLOSE_CAP). */
@@ -73,11 +79,8 @@ const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
 const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
+const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
 const PAGE_SIZE = 100;
-/** 🅢 2026-09-28 (lead decision, channel #20798 04:1x): a run the sweeper cannot see is closed as stalled only when its branch
- *  is not in a host worktree and the draft has been idle this long. A Pod lives at most POD_JOB_DEADLINE_SECONDS (3h), so a
- *  draft idle for 48h cannot belong to a running Pod — the «not in a running Pod» condition follows from the idle time. */
-export const UNOBSERVED_IDLE_CLOSE_HOURS = 48;
 /** At most this many closes per tick, so a wrong rule cannot close everything at once. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
 
@@ -94,7 +97,16 @@ async function collectPages<T>(fetch: (page: number, perPage: number) => Promise
 
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
 export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
-  const result: DraftSweepResult = { repository, apply, complete: false, entries: [] };
+  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
+  const record = (entry: DraftSweepEntry): void => {
+    result.entries.push(entry);
+    result.counts[entry.reason] = (result.counts[entry.reason] ?? 0) + 1;
+    debug.log('drafts.cleanup', 'decided', { number: entry.number, action: entry.action, reason: entry.reason });
+  };
+  const finish = (): DraftSweepResult => {
+    debug.log('drafts.cleanup', 'summary', result.counts);
+    return result;
+  };
   let drafts: SweepDraft[];
   let merged: SweepMergedPr[];
   let liveBranches: ReadonlySet<string> | undefined;
@@ -109,58 +121,90 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       || merged.some((pr) => !Number.isInteger(pr.number) || !pr.branch)) throw new Error('Invalid PR inventory');
   } catch (error) {
     result.error = String(error);
-    return result;
+    return finish();
   }
   let statuses: Map<number, string | undefined>;
+  let finality: Map<number, boolean | undefined>;
+  let latestFileChanges: Map<number, Readonly<Record<string, string>> | undefined>;
   try {
     statuses = new Map<number, string | undefined>();
-    for (const draft of drafts) statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
+    finality = new Map<number, boolean | undefined>();
+    latestFileChanges = new Map<number, Readonly<Record<string, string>> | undefined>();
+    for (const draft of drafts) {
+      const status = await adapters.getRunStatus(draft, repository);
+      // A prior final cannot terminate a new active run on the same draft.
+      const active = status === 'running' || status === 'probable-running';
+      const final = active ? false : await adapters.hasFinalRunResult?.(draft, repository);
+      finality.set(draft.number, final);
+      statuses.set(draft.number, final ? 'self-implement.result final' : status);
+      if (draft.changedFiles?.length && adapters.getLatestFileChanges) {
+        latestFileChanges.set(draft.number, await adapters.getLatestFileChanges(draft, repository));
+      }
+    }
   } catch (error) {
     result.error = String(error);
-    return result;
+    return finish();
   }
   result.complete = true;
   let closes = 0;
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
-  for (const draft of drafts) {
+  for (const listedDraft of drafts) {
+    const draft = { ...listedDraft, latestFileChanges: latestFileChanges.get(listedDraft.number) };
     const runStatus = statuses.get(draft.number);
+    const finalRunResult = finality.get(draft.number);
     const states = stateLabels.filter((state) => draft.labels.includes(state.name));
     const contradiction = states.length > 1 || draft.labels.includes(approvalLabel ?? '');
-    if (!contradiction && draft.labels.includes(keepLabel ?? '')) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: `label:${keepLabel}`, applied: false });
+    if (draft.labels.includes(releaseHoldLabel ?? '') || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
+      const held = draft.labels.includes(keepLabel ?? '') ? keepLabel : releaseHoldLabel;
+      record({ number: draft.number, action: 'keep', reason: `label:${held}`, applied: false });
       continue;
     }
     const isClaimed = !contradiction && draft.labels.includes(runningLabel);
     const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
+    const idleHours = typeof draft.updatedAt === 'string' && Number.isFinite(Date.parse(draft.updatedAt))
+      ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
     // An unobserved claim may still have a merged twin: liveness/holds retain their priority,
     // but a superseded draft must not be hidden by the six-hour claim window.
-    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus: runStatus ?? 'ended-unclosed', mergedTwins: merged, liveBranches, ageHours }) : undefined;
-    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true;
+    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      finalRunResult, ageHours: idleHours }) : undefined;
+    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true
+      || mergedDecision?.reason.startsWith('duplicate-of-open #') === true;
+    if (!contradiction && mergedDecision?.reason === 'branch-finality-unobserved') {
+      record({ number: draft.number, action: 'keep', reason: mergedDecision.reason, applied: false });
+      continue;
+    }
     // Without an observed update time, neither expiration nor a fallback to creation time can authorize mutation —
     // but a merged twin does not need the update time, so superseded keeps its priority over the unobserved claim.
     if (isClaimed && !supersededClaim && (typeof draft.updatedAt !== 'string' || !Number.isFinite(Date.parse(draft.updatedAt)))) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
+      record({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
       continue;
     }
-    const claimIdleHours = draft.updatedAt === undefined ? NaN : (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000;
-    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours < CLAIM_IDLE_HOURS) {
+    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours < CLAIM_IDLE_HOURS) {
       claimed += 1;
-      result.entries.push({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
+      record({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
       continue;
     }
-    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours >= CLAIM_IDLE_HOURS) {
+    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours >= CLAIM_IDLE_HOURS) {
       claimExpired += 1;
-      if (runStatus === 'running' || runStatus === 'probable-running' || liveBranches.has(draft.branch)) {
-        result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
+      if (liveBranches.has(draft.branch) && finalRunResult === undefined
+        && runStatus !== 'running' && runStatus !== 'probable-running') {
+        record({ number: draft.number, action: 'keep', reason: 'branch-finality-unobserved', applied: false });
+        continue;
+      }
+      if (runStatus === 'running' || runStatus === 'probable-running' ||
+        (runStatus !== 'self-implement.result final' && liveBranches.has(draft.branch))) {
+        record({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
         continue;
       }
       const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
       if (action === 'close') closes += 1;
-      const entry: DraftSweepEntry = { number: draft.number, action, reason: action === 'close' ? 'claim-expired' : 'close-cap',
+      const entry: DraftSweepEntry = { number: draft.number, action,
+        reason: action === 'close' ? runStatus === 'self-implement.result final'
+          ? 'claim-expired (self-implement.result final; worktree is not live)' : 'claim-expired' : 'close-cap',
         ...(action === 'close' ? { statusLabel: stalledLabel } : {}), applied: false };
-      result.entries.push(entry);
+      record(entry);
       if (!apply || action !== 'close') continue;
       let labelsChanged = false;
       try {
@@ -168,7 +212,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
         await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — 런·워크트리 없음 · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -178,17 +222,12 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     // Unlabelled non-harness drafts are outside the sweeper's jurisdiction.
     if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
+      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
       continue;
     }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches, ageHours });
-    if (decision.reason === 'unobserved') {
-      unobserved += 1;
-      const idleHours = (now.getTime() - Date.parse(draft.updatedAt ?? draft.createdAt)) / 3_600_000;
-      if (!liveBranches.has(draft.branch) && Number.isFinite(idleHours) && idleHours >= UNOBSERVED_IDLE_CLOSE_HOURS) {
-        decision = { action: 'close', reason: 'unobserved-idle' };
-      }
-    }
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      finalRunResult, ageHours: runStatus ? ageHours : idleHours });
+    if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
       if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
       else closes += 1;
@@ -199,10 +238,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       : decision.reason;
     const isLive = decision.reason === 'live';
     const target = action === 'report' ? undefined : action === 'close'
-      ? decision.reason.startsWith('superseded-by #') ? supersededLabel : stalledLabel
+      ? decision.reason.startsWith('superseded-by #') || decision.reason.startsWith('duplicate-of-open #') ? supersededLabel : stalledLabel
       : isLive ? (states.length ? runningLabel : undefined) : runStatus && (states[0]?.name === runningLabel || states.length === 0) ? stalledLabel : undefined;
     const entry: DraftSweepEntry = { number: draft.number, action, reason, ...(target ? { statusLabel: target } : {}), applied: false };
-    result.entries.push(entry);
+    record(entry);
     if (!apply || action === 'report') continue;
     let labelsChanged = false;
     try {
@@ -213,8 +252,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         labelsChanged = true;
       }
       if (action === 'close') {
-        await adapters.closeDraft(repository, draft.number, decision.reason === 'unobserved-idle'
-          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${UNOBSERVED_IDLE_CLOSE_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
+        await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
+          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
           : `Draft sweep: ${decision.reason}. Branch preserved.`);
       }
       entry.applied = labelsChanged || action === 'close';
@@ -227,5 +266,5 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   result.closed = closes;
   result.claimed = claimed;
   result.claimExpired = claimExpired;
-  return result;
+  return finish();
 }

package/src/self-dev/draft-triage-rules.ts

@@ -1,42 +1,97 @@
 import { PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+import { RELEASE_PATH_LABEL } from './release-path-guard.js';
 
 export interface DraftTriagePr {
   number: number;
   title?: string;
   branch: string;
   labels?: readonly string[];
+  body?: string;
+  mergeCommitMessage?: string;
+  landingVerifiedComments?: readonly string[];
+  createdAt?: string;
+  mergedAt?: string;
+  changedFiles?: readonly string[];
+  /** Latest change to each draft file, from the draft branch's commit history. Missing is not creation time. */
+  latestFileChanges?: Readonly<Record<string, string>>;
 }
 
 export interface DraftTriageInput {
   draft: DraftTriagePr;
   runStatus: string | undefined;
   mergedTwins: readonly DraftTriagePr[];
+  openDrafts?: readonly DraftTriagePr[];
   ageHours: number;
   liveBranches: ReadonlySet<string>;
+  /** false only when the current run's final result has actually been checked and ruled out. */
+  finalRunResult?: boolean;
 }
 
 export type DraftDecision = { action: 'close' | 'keep'; reason: string };
 
 // Labels the sweeper must never close: an approval-waiting state and the human «keep» / release holds (R-PRK3).
-const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>(PR_LABELS
-  .filter((label) => label.sweep.action === 'exclude' || (label.axis === 'state' && label.sweep.action === 'none'))
-  .map((label) => label.name));
+// RELGUARD's release-path hold waits for OP approval — a long wait is not «stale» (TC review #23217).
+const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
+  .filter((label) => label.sweep.action === 'exclude' || (label.sweep.action === 'none' && (label.axis === 'state' || label.axis === 'addon')))
+  .map((label) => label.name), RELEASE_PATH_LABEL]);
 
 const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
+export const branchStem = (branch: string): string | undefined => /^self-impl\/(.+)-[a-f0-9]{8}-r[a-f0-9]+$/i.exec(branch)?.[1];
+const slot = (body?: string): string | undefined => /^칸:\s*(.+?)\s*$/m.exec(body ?? '')?.[1];
+const referencesDraft = (text: string, number: number): boolean =>
+  new RegExp(`(?:\\(수확\\s*#${number}\\s*\\)|\\bsuperseded\\s*#${number}(?!\\d))`, 'i').test(text);
+const landingCommentReferencesDraft = (text: string, number: number): boolean =>
+  new RegExp(`\\blanding-verified\\s*:\\s*(?:draft|superseded|수확)\\s*#${number}(?!\\d)\\b`, 'i').test(text);
 
-export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranches }: DraftTriageInput): DraftDecision {
+export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
-  if (runStatus === 'running' || runStatus === 'probable-running' || (draft.branch && liveBranches.has(draft.branch))) {
+  if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)
+    && finalRunResult === undefined && runStatus !== 'running' && runStatus !== 'probable-running') {
+    return { action: 'keep', reason: 'branch-finality-unobserved' };
+  }
+  if (runStatus === 'running' || runStatus === 'probable-running' ||
+    (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch))) {
     return { action: 'keep', reason: 'live' };
   }
-  // A missing assessment never authorizes a close; unknown is the running-run query's non-running classification.
-  if (!runStatus) return { action: 'keep', reason: 'unobserved' };   // run status unknown — kept, and said so
   const lineage = goalId(draft.branch);
   const twin = mergedTwins.find((pr) => pr.number !== draft.number && (
     (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
   ));
   if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  const stem = branchStem(draft.branch);
+  const createdAt = Date.parse(draft.createdAt ?? '');
+  const newer = stem && draft.title && Number.isFinite(createdAt) ? openDrafts
+    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem
+      && Number.isFinite(Date.parse(pr.createdAt ?? '')) && Date.parse(pr.createdAt!) > createdAt)
+    .sort((a, b) => Date.parse(b.createdAt!) - Date.parse(a.createdAt!) || b.number - a.number)[0] : undefined;
+  if (newer) return { action: 'close', reason: `duplicate-of-open #${newer.number}` };
+  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && (
+    [pr.mergeCommitMessage, pr.body].some((text) => text && referencesDraft(text, draft.number))
+    || pr.landingVerifiedComments?.some((text) => landingCommentReferencesDraft(text, draft.number))
+  ));
+  if (harvest) return { action: 'close', reason: `superseded-by #${harvest.number} (harvest #${draft.number})` };
+  const created = Date.parse(draft.createdAt ?? '');
+  const files = draft.changedFiles;
+  const draftSlot = slot(draft.body);
+  const later = mergedTwins.filter((pr) => pr.number !== draft.number && Number.isFinite(created)
+    && Number.isFinite(Date.parse(pr.mergedAt ?? '')) && Date.parse(pr.mergedAt!) > created
+    && ((lineage && goalId(pr.branch) === lineage) || (draftSlot && slot(pr.body) === draftSlot)));
+  if (files?.length && files.every((file) => {
+    const changed = Date.parse(draft.latestFileChanges?.[file] ?? '');
+    return Number.isFinite(changed) && changed >= created && later.some((pr) =>
+      pr.changedFiles?.includes(file) && Date.parse(pr.mergedAt!) > changed);
+  })) {
+    const covering = later.filter((pr) => pr.changedFiles?.some((file) => files.includes(file)
+      && Date.parse(pr.mergedAt!) > Date.parse(draft.latestFileChanges![file]!)));
+    return { action: 'close', reason: `superseded-by #${covering.map((pr) => pr.number).join(', #')} (all-files-landed)` };
+  }
+  if (!runStatus) return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
+    ? { action: 'close', reason: 'stale-unobserved' }
+    : { action: 'keep', reason: 'unobserved' };
+  if (runStatus === 'self-implement.result final') return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
+    ? { action: 'close', reason: 'stale-ended-run (self-implement.result final; worktree is not live)' }
+    : { action: 'keep', reason: 'recent (self-implement.result final; worktree is not live)' };
   if (Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS) return { action: 'close', reason: 'stale-ended-run' };
   return { action: 'keep', reason: 'recent' };
 }