elanous 0.2.22 → 0.2.24

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

@@ -1,7 +1,10 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { decideDraft, laterMergedTwins, sameGoalPr, type DraftTriagePr } from './draft-triage-rules.js';
+import { decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, laterMergedTwins, sameGoalPr, type DraftTriagePr } from './draft-triage-rules.js';
+import { cardPrNumber, draftTaskOwner, type TaskCard } from '../task-agent/task-hand.js';
+import type { PrTerminalRecord } from './draft-residue.js';
 import { branchLineageSlug } from '../cli/pr-lineage.js';
+import { branchLineageKey } from '../harness/worktree-branch-prefix.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
@@ -35,6 +38,16 @@ export interface DraftSweepAdapters {
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
   /** Current owner, accounting for a later claim release; only draft metrics need this distinction. */
   getActiveClaimOwner?(repository: string, number: number): Promise<string | undefined>;
+  /** Last active claim's run id; undefined for manual claims or after a release. */
+  getActiveClaimRunId?(repository: string, number: number): Promise<string | undefined>;
+  /** When the latest claim marker is a release, its timestamp ('' if unreadable); undefined when no release is latest. */
+  getLastClaimReleaseAt?(repository: string, number: number): Promise<string | undefined>;
+  /** A complete card source; undefined means ownership is unobserved. */
+  listTaskCards?(): Promise<readonly TaskCard[] | undefined>;
+  /** Host ledger terminal records; undefined means the ledger could not be read. */
+  listPrTerminals?(): Promise<readonly PrTerminalRecord[] | undefined>;
+  commentDraft?(repository: string, number: number, body: string): Promise<void>;
+  removeLabel?(repository: string, number: number, label: string): Promise<void>;
   /** 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. */
@@ -48,6 +61,12 @@ export interface DraftSweepAdapters {
   getReviewGate?(draft: SweepDraft, repository: string): Promise<SweepReviewGate | undefined>;
   /** One PR by number (any state); undefined means it could not be read. Only overlap metrics need it. */
   getPr?(repository: string, number: number): Promise<SweepMergedPr | undefined>;
+  /**
+   * Stops the still-live run behind a draft that a newer, also live, same-lineage run supersedes (`--apply` only).
+   * Must reject when the run could not be stopped — the draft is then neither labelled nor closed.
+   * Absent ⇒ a live duplicate is kept, never closed.
+   */
+  supersedeRun?(draft: SweepDraft, repository: string, newer: SweepDraft): Promise<void>;
 }
 
 /** Review PASS and gate posture used only by the daily old-draft count. */
@@ -65,6 +84,8 @@ export interface DraftSweepOptions {
   /** Per-tick close cap; resolve it with resolveDraftSweepCloseCap. Absent or invalid ⇒ DRAFT_SWEEP_CLOSE_CAP. */
   closeCap?: number;
   closeCapSource?: DraftSweepCloseCapSource;
+  /** Closes already made this tick by the pod-terminal replay — they count against the same cap. */
+  alreadyClosed?: number;
 }
 
 export interface DraftSweepEntry {
@@ -117,11 +138,26 @@ export interface DraftMetrics {
   readonly inventory: number;
   readonly oldestAgeHours: number | null;
   readonly needsOwner: number;
+  /** Open running claims whose last update cannot be read; neither owned nor needs-owner. */
+  readonly claimUnobserved?: number;
   readonly converted48h: number;
   readonly cohort48h: number;
   readonly conversion48h: number | null;
 }
 
+/** Default maximum unclaimed open harness drafts for one seat. */
+export const DRAFT_NEEDS_OWNER_SEAT_CAP = 15;
+
+/** Compare one seat's observed needsOwner count; the caller supplies counts of open drafts by seat. */
+export function isSeatDraftNeedsOwnerOverCap(
+  seat: string,
+  needsOwnerBySeat: Readonly<Record<string, number>>,
+  cap = DRAFT_NEEDS_OWNER_SEAT_CAP,
+): boolean {
+  const count = Object.hasOwn(needsOwnerBySeat, seat) ? needsOwnerBySeat[seat] : undefined;
+  return typeof count === 'number' && Number.isFinite(count) && count > cap;
+}
+
 export async function collectDraftMetrics(repository: string, adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listRecentClosed' | 'getActiveClaimOwner'>, now: Date): Promise<DraftMetrics> {
   const clock = now.getTime();
   if (!Number.isFinite(clock)) throw new Error('Invalid draft metric clock');
@@ -160,7 +196,11 @@ export async function collectDraftMetrics(repository: string, adapters: Pick<Dra
   return {
     inventory: open.length,
     oldestAgeHours: open.length ? Math.max(...open.map((pr) => Math.max(0, (clock - Date.parse(pr.createdAt)) / 3_600_000))) : null,
-    needsOwner: owners.filter((owner) => !owner?.trim()).length,
+    needsOwner: open.filter((draft, index) => {
+      const state = draftClaimState(draft, now);
+      return state !== 'unobserved' && (state !== 'claimed' || !owners[index]?.trim());
+    }).length,
+    claimUnobserved: open.filter((draft) => draftClaimState(draft, now) === 'unobserved').length,
     converted48h,
     cohort48h: cohort.length,
     conversion48h: cohort.length ? converted48h / cohort.length : null,
@@ -424,7 +464,9 @@ 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 benchLabel = PR_LABELS.find((entry) => entry.name === 'elanous:bench')!.name;
 const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
+const harvestableLabel = PR_LABELS.find((entry) => entry.name === 'elanous:harvestable')!.name;
 const PAGE_SIZE = 100;
 /** At most this many closes per tick, so a wrong rule cannot close everything at once. Default for `tools.selfImplement.draftSweepCloseCap`. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
@@ -575,9 +617,26 @@ export async function mapBounded<T, R>(items: readonly T[], limit: number, work:
 }
 
 function harnessDraft(draft: SweepDraft): boolean {
+  // BENCH-ISOLATED-ARMS — a bench arm PR is comparison material: the sweep never marks, supersedes or closes it.
+  if (draft.labels.includes(benchLabel)) return false;
   return draft.branch.startsWith('self-impl/') || draft.labels.some((name) => name.startsWith('elanous:'));
 }
 
+/**
+ * The newest open draft of the same goal lineage that was created strictly after `draft` — a rerun
+ * (e.g. a forced requeue) of the same goal. Reads only the branch, so a draft with no task card still has a lineage.
+ * ⛔ A branch without a goal id has no lineage key and never matches.
+ */
+export function newerLineageDraft(draft: SweepDraft, openDrafts: readonly SweepDraft[]): SweepDraft | undefined {
+  const key = branchLineageKey(draft.branch);
+  const created = Date.parse(draft.createdAt);
+  if (key === null || !Number.isFinite(created)) return undefined;
+  return openDrafts
+    .filter((pr) => pr.number !== draft.number && branchLineageKey(pr.branch) === key
+      && Number.isFinite(Date.parse(pr.createdAt)) && Date.parse(pr.createdAt) > created)
+    .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt) || b.number - a.number)[0];
+}
+
 /**
  * Census of harness drafts older than 24h. Same-goal landing uses `sameGoalPr` unchanged.
  * A draft counts as closable when a same-goal merged PR exists, harvestable when review PASS and the gate passed,
@@ -605,15 +664,20 @@ export function draftSweepDaily(
 }
 
 /** 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(), closeCap: requestedCap, closeCapSource: requestedSource }: DraftSweepOptions): Promise<DraftSweepResult> {
+export async function runDraftSweep({ repository, adapters, apply = false, now = new Date(), closeCap: requestedCap, closeCapSource: requestedSource, alreadyClosed = 0 }: DraftSweepOptions): Promise<DraftSweepResult> {
   const validCap = validCloseCap(requestedCap);
   const closeCap = validCap ?? DRAFT_SWEEP_CLOSE_CAP;
   const closeCapSource: DraftSweepCloseCapSource = validCap === undefined ? 'default' : requestedSource ?? 'flag';
   const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {}, closeCap, closeCapSource };
+  // Built once after the inventory (review r4: no per-decision scan of the draft list).
+  const runIdByNumber = new Map<number, string>();
   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 });
+    debug.log('draft.residue', 'sweep-decided', { childRunId: runIdByNumber.get(entry.number) ?? null,
+      number: entry.number, prNumber: entry.number, terminalClass: null, owner: 'unknown', ownerSource: 'unknown',
+      action: entry.action, reason: entry.reason });
   };
   const finish = (): DraftSweepResult => {
     debug.log('drafts.cleanup', 'summary', result.counts);
@@ -651,6 +715,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     return finish();
   }
   timing('inventory', drafts.length + merged.length);
+  for (const pr of drafts) if (pr.runId) runIdByNumber.set(pr.number, pr.runId);
   const statuses = new Map<number, string | undefined>();
   const finality = new Map<number, boolean | undefined>();
   const latestFileChanges = new Map<number, Readonly<Record<string, string>> | undefined>();
@@ -690,26 +755,196 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     timing('review-gate', censused.length);
   }
   result.daily = draftSweepDaily(drafts, merged, now, reviewGate);
+  // Card and terminal inventories are observations, not closing authority. An unreadable source cannot mint a claim.
+  let cards: readonly TaskCard[] | undefined;
+  let terminals: readonly PrTerminalRecord[] | undefined;
+  if (apply) {
+    try { cards = await adapters.listTaskCards?.(); if (cards && !Array.isArray(cards)) cards = undefined; }
+    catch (error) { debug.log('draft.residue', 'claim-skipped', { prNumber: null, owner: null, runId: null, reason: `cards-unreadable: ${sweepFailureReason(error)}` }); }
+    try { terminals = await adapters.listPrTerminals?.(); if (terminals && !Array.isArray(terminals)) terminals = undefined; }
+    catch (error) { debug.log('draft.residue', 'claim-skipped', { prNumber: null, owner: null, runId: null, reason: `terminals-unreadable: ${sweepFailureReason(error)}` }); }
+  }
   result.complete = true;
-  let closes = 0;
+  let closes = Number.isSafeInteger(alreadyClosed) && alreadyClosed > 0 ? alreadyClosed : 0;
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
   for (const listedDraft of drafts) {
-    const draft = { ...listedDraft, latestFileChanges: latestFileChanges.get(listedDraft.number) };
+    const draft = { ...listedDraft, labels: [...listedDraft.labels], latestFileChanges: latestFileChanges.get(listedDraft.number) };
+    let releasedThisTick = false;
+    let claimWriteFailed = false;
+    let claimWriteError: string | undefined;
+    let claimPartialApplied = false;
+    let partialClaimUnowned = false;
+    let releasePending = false;
+    if (apply && harnessDraft(draft) && !draft.labels.some((name) => name === approvalLabel || name === keepLabel || name === releaseHoldLabel)
+      && stateLabels.filter((state) => draft.labels.includes(state.name)).length <= 1
+      && !draft.labels.includes(supersededLabel)) {
+      const logClaim = (event: 'claim-marked' | 'claim-released' | 'claim-skipped', owner: string | null, runId: string | null, reason: string) =>
+        debug.log('draft.residue', event, { prNumber: draft.number, owner, runId, reason });
+      try {
+        const hasTerminal = terminals?.some((record) => record.prNumber === draft.number
+          && record.repository?.toLowerCase() === repository.toLowerCase());
+        const claimRunId = hasTerminal || cards?.length || draft.labels.includes(runningLabel)
+          ? await adapters.getActiveClaimRunId?.(repository, draft.number) : undefined;
+        // A label write can succeed before the claim comment fails. Read the comment too: the label alone
+        // cannot prove ownership, and a manual claim (without a run id) must not be overwritten.
+        const claimOwner = claimRunId || cards?.length || draft.labels.includes(runningLabel)
+          ? await adapters.getActiveClaimOwner?.(repository, draft.number) : undefined;
+        const runTerminal = claimRunId && terminals?.find((record) => record.prNumber === draft.number
+          && record.repository?.toLowerCase() === repository.toLowerCase()
+          && (record.childRunId === claimRunId || cards?.some((card) => card.runId === claimRunId
+            && card.runChildId === record.childRunId
+            && (cardPrNumber(card) === draft.number || (draft.runId && (draft.runId === card.runId || draft.runId === card.runChildId))))));
+        // A seat-attributed terminal releases only its own seat's claim; another owner's claim naming the run is kept.
+        const ownerMismatch = Boolean(runTerminal && runTerminal.ownerSource === 'seat' && claimOwner && runTerminal.owner !== claimOwner);
+        if (ownerMismatch) logClaim('claim-skipped', claimOwner ?? null, claimRunId ?? null, 'terminal-owner-mismatch');
+        const terminal = ownerMismatch ? undefined : runTerminal;
+        releasePending = Boolean(terminal);
+        if (terminal && adapters.commentDraft && (!draft.labels.includes(runningLabel) || adapters.removeLabel)) {
+          if (draft.labels.includes(runningLabel)) {
+            await adapters.removeLabel!(repository, draft.number, runningLabel);
+            draft.labels.splice(draft.labels.indexOf(runningLabel), 1);
+            claimPartialApplied = true;
+          }
+          await adapters.commentDraft(repository, draft.number, draftReleaseComment(now, `run ${claimRunId} · ${terminal.terminalClass}`));
+          releasedThisTick = true;
+          draft.updatedAt = now.toISOString();
+          logClaim('claim-released', terminal.owner, claimRunId ?? null, terminal.terminalClass);
+        } else if (!releasePending && !draft.labels.includes(harvestableLabel)
+          && (draftClaimState(draft, now) === 'unclaimed'
+            || (draft.labels.includes(runningLabel) && adapters.getActiveClaimOwner && adapters.getActiveClaimRunId
+              && !claimOwner && !claimRunId))) {
+          partialClaimUnowned = draft.labels.includes(runningLabel) && !claimOwner && !claimRunId;
+          const owner = cards && draftTaskOwner(cards, draft);
+          const runId = owner?.runChildId ?? owner?.runId;
+          const ownerTerminal = owner ? terminals?.find((record) => record.prNumber === draft.number
+            && record.repository?.toLowerCase() === repository.toLowerCase()
+            && (record.childRunId === runId || record.childRunId === owner.runId)) : undefined;
+          // An explicit release (manual `drafts claim --release` or an earlier automatic one) is respected unless the
+          // owning card was created after it — that card is a resume, not the run the release ended.
+          const releasedAt = owner?.seat && runId && !claimOwner && !claimRunId
+            ? await adapters.getLastClaimReleaseAt?.(repository, draft.number) : undefined;
+          const releaseRespected = releasedAt !== undefined
+            && !(Date.parse(owner!.createdAt) > Date.parse(releasedAt));
+          if (partialClaimUnowned && owner?.seat && runId && ownerTerminal && adapters.removeLabel && adapters.commentDraft
+            && !(ownerTerminal.ownerSource === 'seat' && ownerTerminal.owner !== owner.seat)) {
+            // Label-only partial claim (comment write failed) whose run has since ended: undo the label and say so.
+            await adapters.removeLabel(repository, draft.number, runningLabel);
+            draft.labels.splice(draft.labels.indexOf(runningLabel), 1);
+            claimPartialApplied = true;
+            await adapters.commentDraft(repository, draft.number, draftReleaseComment(now, `run ${runId} · ${ownerTerminal.terminalClass}`));
+            releasedThisTick = true;
+            draft.updatedAt = now.toISOString();
+            logClaim('claim-released', owner.seat, runId, `partial-claim:${ownerTerminal.terminalClass}`);
+          } else if (owner?.seat && runId && terminals && !claimOwner && !claimRunId
+            && !merged.some((pr) => pr.number !== draft.number && sameGoalPr(draft, pr))
+            && !ownerTerminal && !releaseRespected && adapters.commentDraft) {
+            if (!draft.labels.includes(runningLabel)) {
+              await adapters.setLabels(repository, draft.number, { add: runningLabel,
+                remove: stateLabels.filter((state) => draft.labels.includes(state.name)).map((state) => state.name) });
+              draft.labels.splice(0, draft.labels.length, ...draft.labels.filter((name) => !stateLabels.some((state) => state.name === name)), runningLabel);
+              claimPartialApplied = true;
+            }
+            await adapters.commentDraft(repository, draft.number, draftClaimComment(owner.seat, now, `run ${runId}`));
+            draft.updatedAt = now.toISOString();
+            logClaim('claim-marked', owner.seat, runId, 'unique-card');
+          } else logClaim('claim-skipped', owner?.seat ?? null, runId ?? null,
+            !cards ? 'cards-unobserved' : !owner ? 'owner-ambiguous-or-missing' : !terminals ? 'terminals-unobserved'
+              : claimRunId || claimOwner ? 'claim-already-owned' : ownerTerminal ? 'run-terminal'
+                : releaseRespected ? 'release-respected' : 'run-not-live-or-write-unavailable');
+        }
+      } catch (error) {
+        claimWriteFailed = true;
+        claimWriteError = String(error);
+        logClaim('claim-skipped', null, null, `claim-write-failed: ${sweepFailureReason(error)}`);
+      }
+    }
     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 (releasedThisTick || claimWriteFailed || partialClaimUnowned || releasePending) {
+      record({ number: draft.number, action: 'keep', reason: releasedThisTick ? 'claim-released'
+        : claimWriteFailed ? 'claim-write-unobserved' : releasePending ? 'claim-release-unobserved' : 'claim-owner-unobserved', applied: releasedThisTick,
+      ...(claimWriteFailed ? { error: claimWriteError, ...(claimPartialApplied ? { partialApplied: true } : {}) } : {}) });
+      continue;
+    }
     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 claimState = contradiction ? 'unclaimed' : draftClaimState(draft, now);
+    const isClaimed = claimState !== 'unclaimed';
     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;
+    // A newer open draft of the same goal lineage (a rerun, e.g. a forced requeue) supersedes this one even when
+    // its running claim is fresh or its run is still live. Holds, merged twins and the title-based duplicate rule keep their priority.
+    const lineageNewer = contradiction || draft.labels.includes(harvestableLabel) ? undefined : newerLineageDraft(draft, drafts);
+    if (lineageNewer) {
+      const base = decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+        finalRunResult, ageHours: runStatus ? ageHours : idleHours });
+      if (!base.reason.startsWith('label:') && !base.reason.startsWith('superseded-by #') && !base.reason.startsWith('duplicate-of-open #')) {
+        const live = (status: string | undefined, branch: string) => status === 'running' || status === 'probable-running'
+          || (status !== 'self-implement.result final' && liveBranches.has(branch));
+        const runLive = live(runStatus, draft.branch);
+        const lineageKey = branchLineageKey(draft.branch);
+        const reason = `duplicate-of-open #${lineageNewer.number} (lineage ${lineageKey})${runLive ? ` · stop run ${draft.runId ?? 'unknown'}` : ''}`;
+        // Every lineage outcome that does not close falls through to the existing rules (preservation contract):
+        // a duplicate this rule cannot settle is decided exactly as it was before this rule existed.
+        const fallThrough = (why: string) => {
+          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why }); } catch { /* fail-soft */ }
+        };
+        if (runLive && !adapters.supersedeRun) fallThrough('lineage-duplicate-run-live');
+        // Safety (OP 10-11): a live run is stopped only when the newer run of the same lineage is itself live —
+        // never trade a running attempt for one that already ended or was never observed running.
+        else if (runLive && !live(statuses.get(lineageNewer.number), lineageNewer.branch)) fallThrough('lineage-newer-run-not-live');
+        else if (closes >= closeCap) {
+          record({ number: draft.number, action: 'keep', reason: 'close-cap', applied: false });
+          continue;
+        } else {
+          let stopFailed = false;
+          // --apply only: the run is stopped before anything is written; a stop that cannot be confirmed writes nothing.
+          if (apply && runLive) {
+            const observed = { number: draft.number, newer: lineageNewer.number, runId: draft.runId ?? null, newerRunId: lineageNewer.runId ?? null, lineageKey };
+            try {
+              await adapters.supersedeRun!(draft, repository, lineageNewer);
+              try { debug.log('self-dev.draft-sweep', 'supersede-run', observed); } catch { /* fail-soft */ }
+            } catch (error) {
+              stopFailed = true;
+              try { debug.log('self-dev.draft-sweep', 'supersede-run-failed', { ...observed, reason: sweepFailureReason(error) }, { level: 'warn' }); } catch { /* fail-soft */ }
+            }
+          }
+          if (stopFailed) fallThrough('supersede-run-failed');
+          else {
+            // A close is counted against the cap only once it is decided here; a failed write gives the slot back.
+            closes += 1;
+            const entry: DraftSweepEntry = { number: draft.number, action: 'close', reason, statusLabel: supersededLabel, applied: false };
+            record(entry);
+            if (!apply) continue;
+            let labelsChanged = false;
+            try {
+              if (!draft.labels.includes(supersededLabel)) {
+                await adapters.setLabels(repository, draft.number, {
+                  add: supersededLabel, remove: states.map((state) => state.name).filter((name) => name !== supersededLabel),
+                });
+                labelsChanged = true;
+              }
+              await adapters.closeDraft(repository, draft.number,
+                `Draft sweep: ${reason} (https://github.com/${repository}/pull/${lineageNewer.number}). Branch preserved.`);
+              entry.applied = true;
+            } catch (error) {
+              if (labelsChanged) entry.partialApplied = true;
+              else closes -= 1;
+              entry.error = String(error);
+            }
+            continue;
+          }
+        }
+      }
+    }
     // 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, mergedTwins: merged, openDrafts: drafts, liveBranches,
@@ -722,16 +957,16 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     // 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)))) {
+    if (claimState === 'unobserved' && !supersededClaim) {
       record({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
       continue;
     }
-    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours < CLAIM_IDLE_HOURS) {
+    if (claimState === 'claimed' && !supersededClaim) {
       claimed += 1;
       record({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
       continue;
     }
-    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours >= CLAIM_IDLE_HOURS) {
+    if (claimState === 'expired' && !supersededClaim) {
       claimExpired += 1;
       if (liveBranches.has(draft.branch) && finalRunResult === undefined
         && runStatus !== 'running' && runStatus !== 'probable-running') {
@@ -772,6 +1007,12 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
       finalRunResult, ageHours: runStatus ? ageHours : idleHours });
+    const fallback = decision.reason === 'unobserved' || decision.reason === 'stale-unobserved'
+      || decision.reason === 'recent' || decision.reason.startsWith('recent (') || decision.reason.startsWith('stale-ended-run');
+    if (!contradiction && draft.labels.includes(harvestableLabel) && fallback) {
+      decision = Number.isFinite(idleHours) && idleHours >= STALLED_DRAFT_HOURS
+        ? { action: 'close', reason: 'harvest-expired' } : { action: 'keep', reason: 'harvestable' };
+    }
     if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
       if (closes >= closeCap) decision = { action: 'keep', reason: 'close-cap' };
@@ -799,6 +1040,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       if (action === 'close') {
         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.`
+          : decision.reason === 'harvest-expired'
+          ? `Draft sweep: harvest-expired — 종단이 수확 대상으로 표시한 뒤 ${STALLED_DRAFT_HOURS}h 동안 수확 없음. Branch preserved; reopen to restore.`
           : `Draft sweep: ${decision.reason}${decision.reason.startsWith('superseded-by #')
             ? ` (https://github.com/${repository}/pull/${decision.reason.slice('superseded-by #'.length).match(/^\d+/)![0]})` : ''}. Branch preserved.`);
       }
@@ -811,7 +1054,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   timing('decide', drafts.length);
   try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length, closed: closes, closeCap, closeCapSource }); } catch { /* fail-soft */ }
   result.unobserved = unobserved;
-  result.closed = closes;
+  // `closed` stays «closed by this sweep»; replay closes only consume the shared cap (alreadyClosed).
+  result.closed = closes - (Number.isSafeInteger(alreadyClosed) && alreadyClosed > 0 ? alreadyClosed : 0);
   result.claimed = claimed;
   result.claimExpired = claimExpired;
   return finish();

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

@@ -1,6 +1,22 @@
-import { PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { RELEASE_PATH_LABEL } from './release-path-guard.js';
 
+export function draftClaimComment(owner: string, at: Date, note?: string): string {
+  return `🔧 처리 중 — owner ${owner} · ${at.toISOString()}${note?.trim() ? ` · ${note.trim()}` : ''}`;
+}
+
+export function draftReleaseComment(at: Date, note?: string): string {
+  return `🔧 처리 끝 — ${at.toISOString()}${note?.trim() ? ` · ${note.trim()}` : ''}`;
+}
+
+/** No timestamp is an observation gap, not an expired claim. */
+export function draftClaimState(draft: { labels: readonly string[]; updatedAt?: string }, now: Date): 'claimed' | 'expired' | 'unclaimed' | 'unobserved' {
+  if (!draft.labels.includes('elanous:running') || draft.labels.includes('elanous:harvestable')) return 'unclaimed';
+  const updated = typeof draft.updatedAt === 'string' ? Date.parse(draft.updatedAt) : NaN;
+  if (!Number.isFinite(updated)) return 'unobserved';
+  return (now.getTime() - updated) / 3_600_000 < CLAIM_IDLE_HOURS ? 'claimed' : 'expired';
+}
+
 export interface DraftTriagePr {
   number: number;
   title?: string;
@@ -44,6 +60,16 @@ export const isAutoTitle = (title: string): boolean =>
   /^[\w./-]+:\s*[^\s,]+\.[a-z0-9]+(?:\s*,\s*[^\s,]+\.[a-z0-9]+)*$/i.test(title.trim());
 
 /** Same goal (TC 10-05): ① both carry a goal identifier → compare it ② otherwise exact title ⊕ both harness drafts ⊕ same branch stem, never an auto title ③ else false. */
+/** Same goal only when a verified goal identifier matches on both sides (branch goal id, else the body's «골:» line).
+ *  Unlike sameGoalPr it never falls back to titles or branch stems — used where a match closes a PR. */
+export function sameVerifiedGoal(a: DraftTriagePr, b: DraftTriagePr): boolean {
+  const idA = goalId(a.branch), idB = goalId(b.branch);
+  if (idA && idB) return idA === idB;
+  // Review r7: a branch goal id on only one side cannot be checked against the other — never close on body text then.
+  if (idA || idB) return false;
+  const textA = goalText(a.body), textB = goalText(b.body);
+  return Boolean(textA && textB && textA === textB);
+}
 export function sameGoalPr(a: DraftTriagePr, b: DraftTriagePr): boolean {
   const idA = goalId(a.branch), idB = goalId(b.branch);
   if (idA && idB) return idA === idB;

package/src/self-dev/graph-journey-route.ts

@@ -103,3 +103,9 @@ export function intakeTakesQueue(label: 'queued' | 'direct', route: Pick<Journey
   const graphQueues = route.source === 'graph' ? route.to === 'queue' : label === 'queued';
   return graphQueues && eligible;
 }
+
+/** 병합 직전 동결 검사의 «승인 요구» — 동결이 아닌(open) 병합을 그래프가 hold 로 보내면 true.
+ *  ⛔ 그래프가 답을 못 내면(code-default) false — 오늘의 입장 판정 그대로. 동결·선점(frozen·taken)은 이미 코드가 정했다. */
+export function freezeCheckHolds(label: 'open' | 'frozen' | 'taken', route: Pick<JourneyRoute, 'source' | 'to'>): boolean {
+  return label === 'open' && route.source === 'graph' && route.to === 'hold';
+}