elanous 0.2.32 → 0.2.35

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

@@ -1,6 +1,7 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, laterMergedTwins, sameGoalPr, type DraftTriagePr } from './draft-triage-rules.js';
+import { assessDraftTriage, decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, laterMergedTwins, sameGoalPr, PROTECTED_LABELS, type DraftTriageAssessment, type DraftTriagePr, type DraftTriageReviewState } from './draft-triage-rules.js';
+import { cellIdFromBody } from '../pr-tool/census.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';
@@ -25,6 +26,8 @@ export interface SweepMergedPr extends DraftTriagePr {
 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[]>;
+  /** Head commit time is fetched only for explicit triage, where it gates idle/close recommendations. */
+  getHeadCommitTime?(repository: string, number: number): Promise<string | undefined>;
   listMerged(page: number, perPage: number, repository: string): Promise<readonly SweepMergedPr[]>;
   /** Complete closed PR inventory for the creation cohort (including closed without merge). */
   listRecentClosed?(repository: string, createdSince: Date): Promise<readonly SweepMergedPr[]>;
@@ -47,6 +50,8 @@ export interface DraftSweepAdapters {
   /** 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>;
+  /** Complete issue-comment inventory for idempotent merge-time same-cell cleanup. */
+  listIssueComments?(repository: string, number: number): Promise<readonly string[]>;
   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>;
@@ -74,6 +79,8 @@ export interface SweepReviewGate {
   readonly review?: 'pass' | 'fail';
   readonly mustFix?: boolean;
   readonly gate?: 'pass' | 'fail';
+  /** Exact-head review posture for triage; unknown stays distinct from legacy census posture. */
+  readonly triageReview?: DraftTriageReviewState;
 }
 
 export interface DraftSweepOptions {
@@ -86,6 +93,8 @@ export interface DraftSweepOptions {
   closeCapSource?: DraftSweepCloseCapSource;
   /** Closes already made this tick by the pod-terminal replay — they count against the same cap. */
   alreadyClosed?: number;
+  /** Include evidence-backed next-action recommendations in JSON output; never authorizes writes. */
+  includeTriage?: boolean;
 }
 
 export interface DraftSweepEntry {
@@ -104,6 +113,7 @@ export interface DraftSweepResult {
   apply: boolean;
   complete: boolean;
   entries: DraftSweepEntry[];
+  triage?: { entries: Array<{ number: number; assessment: DraftTriageAssessment }>; counts: Record<string, number> };
   counts: Record<string, number>;
   /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
   unobserved?: number;
@@ -133,6 +143,11 @@ export interface DraftSweepLineageCounts {
   closed: number;
   harvestableClosed: number;
   fallThrough: Record<string, number>;
+  /**
+   * Of `closed`, the ones the 칸 (cell) key decided instead of the branch lineage key. Absent while the 칸 rule
+   * closes nothing, so every existing lineage count and log line keeps its exact shape.
+   */
+  cellClosed?: number;
 }
 
 /** A review counts as passed only on an observed PASS with no must-fix left. */
@@ -587,12 +602,14 @@ export function resolveDraftSweepCloseCap(input: { flag?: unknown; config?: unkn
   return { closeCap: DRAFT_SWEEP_CLOSE_CAP, closeCapSource: 'default', warnings };
 }
 
-/** Post-merge shortcut: only the existing superseded-by decision can authorize a close. */
+/** Post-merge cleanup: an explicit same-cell successor or the existing verified-goal decision can authorize a close. */
 export async function supersedeDraftsOnMerge(input: {
   repository: string;
   merged: SweepMergedPr & { createdAt: string; mergedAt: string };
+  /** `pr land` and HQ train invoke only the explicit same-cell successor path. */
+  onlyExplicitSameCell?: boolean;
   adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listLiveBranches' | 'getRunStatus' | 'setLabels' | 'closeDraft'>
-    & Pick<Partial<DraftSweepAdapters>, 'getLatestFileChanges' | 'getPrFiles'>;
+    & Pick<Partial<DraftSweepAdapters>, 'getLatestFileChanges' | 'getPrFiles' | 'commentDraft' | 'listIssueComments'>;
 }): Promise<{ closed: number[]; kept: number[] }> {
   const { repository, merged, adapters } = input;
   const closed: number[] = [];
@@ -611,6 +628,43 @@ export async function supersedeDraftsOnMerge(input: {
       || !Number.isFinite(Date.parse(merged.createdAt)) || !Number.isFinite(Date.parse(merged.mergedAt))
       || drafts.some((pr) => !Number.isInteger(pr.number) || !pr.branch || !Array.isArray(pr.labels)
         || !Number.isFinite(Date.parse(pr.createdAt)))) throw new Error('Incomplete merge draft inventory');
+    // The conflicting-PR path writes this exact marker. A marker by itself is not authority:
+    // both PR bodies must identify the same cell, and the old PR must still be an open draft.
+    const markers = [...(merged.body ?? '').matchAll(/^Supersedes:\s*#(\d+)\s*$/gm)];
+    const markedNumber = markers.length === 1 ? Number(markers[0]![1]) : null;
+    const explicitOld = Number.isSafeInteger(markedNumber) && markedNumber! > 0 ? markedNumber : null;
+    const mergedCell = cellIdFromBody(merged.body ?? '');
+    if (explicitOld && explicitOld !== merged.number && mergedCell) {
+      const old = drafts.find((draft) => draft.number === explicitOld);
+      if (old && cellIdFromBody(old.body ?? '') === mergedCell
+        && Date.parse(old.createdAt) < Date.parse(merged.mergedAt)
+        && !old.labels.some((label) => PROTECTED_LABELS.has(label))
+        && PR_LABELS.filter((label) => label.axis === 'state' && old.labels.includes(label.name)).length <= 1) {
+        const marker = `<!-- elanous:same-cell-superseded #${old.number} -> #${merged.number} -->`;
+        const comment = `${marker}\nSame-cell draft superseded by merged PR #${merged.number} (https://github.com/${repository}/pull/${merged.number}). Branch preserved.`;
+        try {
+          if (!adapters.listIssueComments || !adapters.commentDraft) throw new Error('same-cell comment inventory unavailable');
+          const comments = await adapters.listIssueComments(repository, old.number);
+          if (!Array.isArray(comments)) throw new Error('same-cell comment inventory incomplete');
+          const remove = stateLabels.filter((label) => old.labels.includes(label.name) && label.name !== supersededLabel).map((label) => label.name);
+          if (!old.labels.includes(supersededLabel)) await adapters.setLabels(repository, old.number, { add: supersededLabel, remove });
+          if (!comments.some((body) => body.includes(marker))) await adapters.commentDraft(repository, old.number, comment);
+          await adapters.closeDraft(repository, old.number);
+          closed.push(old.number);
+          closeAttempts += 1;
+        } catch (failure) {
+          failed.push(old.number);
+          error = String(failure);
+          debug.log('drafts.cleanup', 'same-cell-supersede-failed', { merged: merged.number, old: old.number, error });
+        }
+      }
+    }
+    if (input.onlyExplicitSameCell) {
+      kept.push(...drafts.map((draft) => draft.number).filter((number) => !closed.includes(number)));
+      debug.log('drafts.cleanup', 'superseded-on-merge', { merged: merged.number, closed, kept,
+        ...(failed.length ? { failed } : {}), ...(error ? { error } : {}) });
+      return { closed, kept };
+    }
     const statuses = new Map<number, string | undefined>();
     const latestChanges = new Map<number, Readonly<Record<string, string>> | undefined>();
     const mergedFiles = await adapters.getPrFiles?.(repository, merged.number);
@@ -625,7 +679,14 @@ export async function supersedeDraftsOnMerge(input: {
       }
     }
     for (const listedDraft of drafts) {
+      if (closed.includes(listedDraft.number)) continue;
       const draft = { ...listedDraft, latestFileChanges: latestChanges.get(listedDraft.number) };
+      // The same-cell route is never inferred from a title, goal, or file overlap.
+      // A failed explicit cleanup also stays open for a later retry instead of falling through to generic triage.
+      if (draft.number === explicitOld || (mergedCell && cellIdFromBody(draft.body ?? '') === mergedCell)) {
+        kept.push(draft.number);
+        continue;
+      }
       if (draft.number === merged.number || !draft.branch.startsWith('self-impl/') || liveBranches.has(draft.branch)
         || Date.parse(draft.createdAt) >= Date.parse(merged.mergedAt)) {
         kept.push(draft.number);
@@ -724,6 +785,30 @@ export function newerLineageDraft(draft: SweepDraft, openDrafts: readonly SweepD
     .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt) || b.number - a.number)[0];
 }
 
+/**
+ * The newest open draft of the same 칸 (cell) that was created strictly after `draft` and belongs to a different
+ * goal lineage — two runs of different goals working the same cell are duplicates of one deliverable.
+ * Reads the canonical cell identity (`cellIdFromBody`, the same `칸: <CELL>` marker the PR creation guard uses),
+ * never a re-derived marker, and keeps `branchLineageKey` byte-compatible: only a *different* key is a cell match.
+ * ⛔ A draft whose body names no 칸 never matches (keep), and a same-칸 draft of the same goal is `newerLineageDraft`.
+ */
+export function newerSameCellDraft(draft: SweepDraft, openDrafts: readonly SweepDraft[]): SweepDraft | undefined {
+  const cellId = cellIdFromBody(draft.body ?? '');
+  const created = Date.parse(draft.createdAt);
+  if (cellId === null || !Number.isFinite(created)) return undefined;
+  const key = branchLineageKey(draft.branch);
+  // A missing goal id is not evidence of a different goal. Keep unknown lineage on either side.
+  if (key === null) return undefined;
+  return openDrafts
+    .filter((pr) => {
+      const openKey = branchLineageKey(pr.branch);
+      return pr.number !== draft.number && cellIdFromBody(pr.body ?? '') === cellId
+        && openKey !== null && openKey !== 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,
@@ -751,7 +836,7 @@ 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, alreadyClosed = 0 }: DraftSweepOptions): Promise<DraftSweepResult> {
+export async function runDraftSweep({ repository, adapters, apply = false, now = new Date(), closeCap: requestedCap, closeCapSource: requestedSource, alreadyClosed = 0, includeTriage = false }: DraftSweepOptions): Promise<DraftSweepResult> {
   const validCap = validCloseCap(requestedCap);
   const closeCap = validCap ?? DRAFT_SWEEP_CLOSE_CAP;
   const closeCapSource: DraftSweepCloseCapSource = validCap === undefined ? 'default' : requestedSource ?? 'flag';
@@ -829,7 +914,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   const reviewGate = new Map<number, SweepReviewGate | undefined>();
   if (adapters.getReviewGate) {
     // Review/gate posture only feeds the daily census, which only counts harness drafts older than 24h.
-    const censused = drafts.filter((draft) => dailyCensusDraft(draft, now));
+    const censused = includeTriage ? drafts : drafts.filter((draft) => dailyCensusDraft(draft, now));
     try {
       await mapBounded(censused, DRAFT_SWEEP_CONCURRENCY, async (draft) => {
         reviewGate.set(draft.number, await adapters.getReviewGate!(draft, repository));
@@ -845,12 +930,89 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   // 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) {
+  if (apply || includeTriage) {
     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)}` }); }
   }
+  if (includeTriage) {
+    const latestCommitTimes = new Map<number, string | undefined>();
+    if (adapters.getHeadCommitTime) {
+      await mapBounded(drafts, DRAFT_SWEEP_CONCURRENCY, async (draft) => {
+        latestCommitTimes.set(draft.number, draft.latestCommitAt ?? await adapters.getHeadCommitTime!(repository, draft.number).catch(() => undefined));
+      });
+    }
+    const triageDrafts = drafts.map((draft) => ({ ...draft,
+      ...(latestCommitTimes.has(draft.number) ? { latestCommitAt: latestCommitTimes.get(draft.number) } : {}),
+    }));
+    const triageRows: Array<{ number: number; assessment: DraftTriageAssessment }> = [];
+    const initial = triageDrafts.map((draft) => {
+      const posture = reviewGate.get(draft.number);
+      return assessDraftTriage({ draft, now, runStatus: statuses.get(draft.number),
+        ...(posture?.gate ? { gate: posture.gate } : {}),
+        ...(posture?.triageReview ? { review: posture.triageReview } : {}),
+      });
+    });
+    const activeOwnerObservations = new Map<number, { owner?: string; observed: boolean }>();
+    if (adapters.getActiveClaimOwner) {
+      const ownerLookupDrafts = triageDrafts.filter((draft) => !(cards && draftTaskOwner(cards, draft)));
+      await mapBounded(ownerLookupDrafts, DRAFT_SWEEP_CONCURRENCY, async (draft) => {
+        try {
+          activeOwnerObservations.set(draft.number, { owner: await adapters.getActiveClaimOwner!(repository, draft.number), observed: true });
+        } catch {
+          activeOwnerObservations.set(draft.number, { observed: false });
+        }
+      });
+    }
+    for (let index = 0; index < drafts.length; index++) {
+      const draft = triageDrafts[index]!;
+      const identity = initial[index]!;
+      // A generic sweep can target any repository, while the checklist is machine-wide.
+      // Until checklist observations are repository-bound, leave cell status unknown so close-a stays human.
+      const draftCreatedAt = Date.parse(draft.createdAt);
+      let newerSameCellSameCard: boolean | undefined;
+      if (identity.origin && identity.cellId && identity.cardId && Number.isFinite(draftCreatedAt)) {
+        let uncertainMatch = false;
+        newerSameCellSameCard = false;
+        for (let otherIndex = 0; otherIndex < triageDrafts.length; otherIndex++) {
+          if (otherIndex === index) continue;
+          const other = triageDrafts[otherIndex]!;
+          const otherIdentity = initial[otherIndex];
+          const otherCreatedAt = Date.parse(other.createdAt);
+          if (Number.isFinite(otherCreatedAt) && otherCreatedAt <= draftCreatedAt) continue;
+          if (otherIdentity?.origin && otherIdentity.origin !== identity.origin) continue;
+          if (otherIdentity?.cellId && otherIdentity.cellId !== identity.cellId) continue;
+          if (otherIdentity?.cardId && otherIdentity.cardId !== identity.cardId) continue;
+          if (!Number.isFinite(otherCreatedAt) || !otherIdentity?.origin || !otherIdentity.cellId || !otherIdentity.cardId) {
+            uncertainMatch = true;
+            continue;
+          }
+          newerSameCellSameCard = true;
+          break;
+        }
+        if (newerSameCellSameCard !== true && uncertainMatch) newerSameCellSameCard = undefined;
+      }
+      const ownerCard = cards ? draftTaskOwner(cards, draft) : undefined;
+      // A cell can have several cards and PRs. Terminal evidence belongs to this draft only by exact PR number;
+      // the terminal `card` field can identify the cell, not this card.
+      const cellTerminals = terminals?.filter((terminal) => terminal.repository === repository && terminal.prNumber === draft.number);
+      const activeOwnerObservation = ownerCard ? undefined : activeOwnerObservations.get(draft.number);
+      const posture = reviewGate.get(draft.number);
+      const assessment = assessDraftTriage({ draft, now, runStatus: statuses.get(draft.number),
+        ...(posture?.gate ? { gate: posture.gate } : {}),
+        ...(posture?.triageReview ? { review: posture.triageReview } : {}),
+        newerSameCellSameCard,
+        ownerConfirmed: ownerCard?.seat ? true : !activeOwnerObservation?.observed ? undefined : Boolean(activeOwnerObservation.owner?.trim()),
+      });
+      const terminalEvidence = terminals === undefined ? 'PrTerminalRecord 미관측'
+        : `PrTerminalRecord: cell=${identity.cellId ?? 'unknown'} matched=${cellTerminals?.length ?? 0}`;
+      triageRows.push({ number: draft.number, assessment: { ...assessment, evidence: [...assessment.evidence, terminalEvidence] } });
+    }
+    const triageCounts: Record<string, number> = {};
+    for (const row of triageRows) triageCounts[row.assessment.nextAction] = (triageCounts[row.assessment.nextAction] ?? 0) + 1;
+    result.triage = { entries: triageRows, counts: triageCounts };
+  }
   result.complete = true;
   let closes = Number.isSafeInteger(alreadyClosed) && alreadyClosed > 0 ? alreadyClosed : 0;
   let unobserved = 0;
@@ -858,6 +1020,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   let claimExpired = 0;
   const lineageCounts: DraftSweepLineageCounts = { closed: 0, harvestableClosed: 0, fallThrough: {} };
   result.lineage = lineageCounts;
+  // 칸-keyed closes this tick; published on `lineageCounts` only when the 칸 rule fires (existing shapes stay byte-identical).
+  let cellClosed = 0;
   // Review posture for the harvestable lineage check, reusing the census lookups (one lookup per PR per tick).
   const postureFor = async (pr: SweepDraft): Promise<SweepReviewGate | undefined> => {
     if (!reviewGate.has(pr.number)) reviewGate.set(pr.number, await adapters.getReviewGate!(pr, repository));
@@ -980,7 +1144,11 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     // reruns open until the 24h idle expiry. It is still protected when its own review passed and the newer one's did not.
     const harvestable = draft.labels.includes(harvestableLabel);
     const lineageNewer = contradiction ? undefined : newerLineageDraft(draft, drafts);
-    if (lineageNewer) {
+    // A different goal working the same 칸 is invisible to the branch lineage key, so the canonical 칸 identity decides it.
+    // The lineage key keeps priority: a same-goal rerun stays a lineage outcome even when both drafts share the 칸.
+    const cellNewer = contradiction || lineageNewer ? undefined : newerSameCellDraft(draft, drafts);
+    const duplicateNewer = lineageNewer ?? cellNewer;
+    if (duplicateNewer) {
       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 #')) {
@@ -988,12 +1156,14 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
           || (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'}` : ''}`;
+        const cellId = cellNewer ? cellIdFromBody(draft.body ?? '') : null;
+        const duplicateOf = cellNewer ? `cell ${cellId}` : `lineage ${lineageKey}`;
+        const reason = `duplicate-of-open #${duplicateNewer.number} (${duplicateOf})${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) => {
           lineageCounts.fallThrough[why] = (lineageCounts.fallThrough[why] ?? 0) + 1;
-          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why, harvestable }); } catch { /* fail-soft */ }
+          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: duplicateNewer.number, lineageKey, ...(cellId === null ? {} : { cellId }), why, harvestable }); } catch { /* fail-soft */ }
         };
         // A harvestable draft yields only to a newer draft at least as complete: an observed review PASS on the old one
         // is kept unless the newer one passed review too. Unobservable review posture keeps the old draft (fail-closed).
@@ -1002,17 +1172,19 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
           if (!adapters.getReviewGate) harvestProtection = 'lineage-harvestable-review-unobserved';
           else {
             try {
-              const [oldPosture, newPosture] = [await postureFor(draft), await postureFor(lineageNewer)];
+              const [oldPosture, newPosture] = [await postureFor(draft), await postureFor(duplicateNewer)];
               if (oldPosture === undefined) harvestProtection = 'lineage-harvestable-review-unobserved';
               else if (reviewPassed(oldPosture) && !reviewPassed(newPosture)) harvestProtection = 'lineage-harvestable-review-pass-protected';
             } catch { harvestProtection = 'lineage-harvestable-review-unobserved'; }
           }
         }
         if (harvestProtection) fallThrough(harvestProtection);
+        // `supersedeRun` is same-lineage authority only: a live 칸 duplicate is kept for the existing rules instead.
+        else if (cellNewer && runLive) fallThrough('cell-duplicate-run-live');
         else 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 (runLive && !live(statuses.get(duplicateNewer.number), duplicateNewer.branch)) fallThrough('lineage-newer-run-not-live');
         else if (closes >= closeCap) {
           record({ number: draft.number, action: 'keep', reason: 'close-cap', applied: false });
           continue;
@@ -1020,9 +1192,9 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
           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 };
+            const observed = { number: draft.number, newer: duplicateNewer.number, runId: draft.runId ?? null, newerRunId: duplicateNewer.runId ?? null, lineageKey };
             try {
-              await adapters.supersedeRun!(draft, repository, lineageNewer);
+              await adapters.supersedeRun!(draft, repository, duplicateNewer);
               try { debug.log('self-dev.draft-sweep', 'supersede-run', observed); } catch { /* fail-soft */ }
             } catch (error) {
               stopFailed = true;
@@ -1035,6 +1207,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
             closes += 1;
             lineageCounts.closed += 1;
             if (harvestable) lineageCounts.harvestableClosed += 1;
+            if (cellNewer) cellClosed += 1;
             const entry: DraftSweepEntry = { number: draft.number, action: 'close', reason, statusLabel: supersededLabel, applied: false };
             record(entry);
             if (!apply) continue;
@@ -1054,6 +1227,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
                 closes -= 1;
                 lineageCounts.closed -= 1;
                 if (harvestable) lineageCounts.harvestableClosed -= 1;
+                if (cellNewer) cellClosed -= 1;
               }
               entry.error = String(error);
             }
@@ -1163,6 +1337,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
   }
   timing('decide', drafts.length);
+  if (cellClosed > 0) lineageCounts.cellClosed = cellClosed;
   try { debug.log('self-dev.draft-sweep', 'lineage-summary', { ...lineageCounts, apply }); } catch { /* fail-soft */ }
   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;

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

@@ -30,6 +30,113 @@ export interface DraftTriagePr {
   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>>;
+  /** Latest head commit, separate from PR updatedAt (labels/comments also update that). */
+  latestCommitAt?: string;
+}
+
+export type DraftTriageNextAction = 'close-a' | 'close-c' | 'human';
+export type DraftTriageReviewState = 'approved' | 'changes-requested' | 'commented' | 'dismissed' | 'pending' | 'unknown';
+export type DraftTriageCheck = { state: 'yes' | 'no' | 'unknown'; evidence: string };
+export interface DraftTriageAssessment {
+  origin: string | null;
+  cellId: string | null;
+  cardId: string | null;
+  gate: 'pass' | 'fail' | 'unknown';
+  review: DraftTriageReviewState;
+  cellStatus: 'green' | 'yellow' | 'red' | 'done' | 'unknown';
+  nextAction: DraftTriageNextAction;
+  checks: Readonly<Record<'provenance' | 'gate' | 'review' | 'cell-complete' | 'cell-status-repository-bound' | 'replacement-landed' | 'newer-same-card' | 'idle-48h' | 'protected' | 'recent-commit' | 'running' | 'owner-confirmed', DraftTriageCheck>>;
+  evidence: readonly string[];
+}
+
+export interface DraftTriageAssessmentInput {
+  draft: DraftTriagePr;
+  now: Date;
+  runStatus?: string;
+  gate?: 'pass' | 'fail';
+  review?: DraftTriageReviewState;
+  cellStatus?: 'green' | 'yellow' | 'red' | 'done';
+  /** Repository identity attached to the cell-status observation, when available. */
+  cellStatusRepository?: string;
+  /** Repository targeted by this triage request. */
+  targetRepository?: string;
+  newerSameCellSameCard?: boolean;
+  ownerConfirmed?: boolean;
+}
+
+const CLOSE_PROTECTED_LABELS = new Set([
+  'elanous:running', 'elanous:keep', 'elanous:release-hold', 'elanous:idea-approval',
+  'elanous:harvest-claimed', 'triage:land', 'triage:active',
+]);
+const TRIAGE_TERMINAL_RUN_STATUSES = new Set(['completed', 'failed', 'cancelled', 'abandoned', 'self-implement.result final']);
+
+/** Evidence-first recommendation. Unknown evidence always routes to a person. */
+export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriageAssessment {
+  const { draft, now } = input;
+  const originLabels = (draft.labels ?? []).filter((name) => /^elanous:from-[a-z0-9-]+$/.test(name));
+  const origin = originLabels.length === 1 ? originLabels[0]! : null;
+  const bodyLines = (draft.body ?? '').split(/\r?\n/);
+  const cellMarkerLines = bodyLines.filter((line) => /^\s*칸\s*:/.test(line));
+  const cellRows = bodyLines.flatMap((line) => {
+    const match = /^칸:\s*([^\r\n]*)$/.exec(line);
+    return match ? [match[1]!.trim()] : [];
+  });
+  const cellValues = new Set(cellRows);
+  const cellId = cellMarkerLines.length === cellRows.length && cellRows.length > 0 && cellValues.size === 1
+    && /^[A-Z][A-Z0-9-]{2,}$/.test(cellRows[0]!) ? cellRows[0]! : null;
+  const cardMarkerLines = bodyLines.filter((line) => /^\s*카드\s*:/.test(line));
+  const cardRows = bodyLines.flatMap((line) => {
+    const match = /^카드:[ \t]*([^\r\n]+)[ \t]*$/.exec(line);
+    return match ? [match[1]!.trim()] : [];
+  });
+  const cardId = cardMarkerLines.length === cardRows.length && cardRows.length > 0
+    && cardRows.every((value) => value === cardRows[0])
+    && /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(cardRows[0]!) ? cardRows[0]! : null;
+  const provenance = Boolean(origin && cellId && cardId);
+  const latestCommit = Date.parse(draft.latestCommitAt ?? '');
+  const clock = now.getTime();
+  const ageHours = Number.isFinite(latestCommit) && Number.isFinite(clock) ? (clock - latestCommit) / 3_600_000 : NaN;
+  const protectedLabel = (draft.labels ?? []).find((name) => CLOSE_PROTECTED_LABELS.has(name));
+  const protectedState = Boolean(protectedLabel);
+  const running = input.runStatus === 'running' || input.runStatus === 'probable-running'
+    || (draft.labels ?? []).includes('elanous:running');
+  const cellComplete = input.cellStatus === 'green' || input.cellStatus === 'done';
+  const hasCellStatusRepositoryIdentity = Boolean(input.cellStatusRepository?.trim() && input.targetRepository?.trim());
+  const cellStatusRepositoryBound = hasCellStatusRepositoryIdentity
+    && input.cellStatusRepository!.trim().toLowerCase() === input.targetRepository!.trim().toLowerCase();
+  const releaseCutoff = Number.isFinite(clock) ? (() => {
+    const date = new Date(clock);
+    const cutoff = new Date(date);
+    cutoff.setUTCHours(0, 30, 0, 0); // 09:30 KST
+    return clock < cutoff.getTime() ? cutoff.getTime() - 86_400_000 : cutoff.getTime();
+  })() : NaN;
+  const recentCommit = Number.isFinite(latestCommit) && Number.isFinite(releaseCutoff) && latestCommit > releaseCutoff;
+  const runNotRunning = input.runStatus !== undefined && TRIAGE_TERMINAL_RUN_STATUSES.has(input.runStatus) && !running;
+  // Closing requires positive evidence that the head predates today's release cutoff.
+  // Missing timestamps are unknown, so they cannot authorize a close recommendation.
+  const closeEligible = provenance && !protectedState && Number.isFinite(latestCommit) && !recentCommit && runNotRunning;
+  const idle48h = Number.isFinite(ageHours) && ageHours >= 48;
+  let nextAction: DraftTriageNextAction = 'human';
+  if (closeEligible && cellComplete && cellStatusRepositoryBound) nextAction = 'close-a';
+  else if (closeEligible && idle48h && input.ownerConfirmed === true) nextAction = 'close-c';
+
+  const checks = {
+    provenance: { state: provenance ? 'yes' : 'unknown', evidence: provenance ? `origin=${origin}; cell=${cellId}; card=${cardId}` : '출처·유효 칸·카드 표지가 모두 확인되지 않음' },
+    gate: { state: input.gate === undefined ? 'unknown' : input.gate === 'pass' ? 'yes' : 'no', evidence: `gate=${input.gate ?? 'unknown'}` },
+    review: { state: input.review === undefined || input.review === 'unknown' ? 'unknown' : input.review === 'approved' ? 'yes' : 'no', evidence: `latest exact-head review=${input.review ?? 'unknown'}` },
+    'cell-complete': { state: input.cellStatus && cellStatusRepositoryBound ? (cellComplete ? 'yes' : 'no') : 'unknown', evidence: input.cellStatus ? `cell=${cellId ?? 'unknown'} status=${input.cellStatus}${cellStatusRepositoryBound ? '' : ' (저장소 귀속 미확인)'}` : `칸 상태 미관측${cellId ? ` (${cellId})` : ''}` },
+    'cell-status-repository-bound': { state: cellStatusRepositoryBound ? 'yes' : hasCellStatusRepositoryIdentity ? 'no' : 'unknown', evidence: cellStatusRepositoryBound ? `칸 상태 저장소=${input.cellStatusRepository}; 대상 저장소=${input.targetRepository}` : hasCellStatusRepositoryIdentity ? `칸 상태 저장소=${input.cellStatusRepository}; 대상 저장소=${input.targetRepository} (불일치)` : '칸 상태의 대상 저장소 귀속 미확인' },
+    'replacement-landed': { state: 'unknown', evidence: '현재 adapter는 같은 칸 병합 PR과 이 초안의 대체 관계를 증명하지 않음; follow-up 필요' },
+    'newer-same-card': { state: input.newerSameCellSameCard === undefined ? 'unknown' : input.newerSameCellSameCard ? 'yes' : 'no', evidence: `${input.newerSameCellSameCard === undefined ? '같은 칸·카드 새 draft 관계 미관측' : `same-cell-same-card-newer=${input.newerSameCellSameCard}`}; 관측 표지이며 대체 증거가 아님` },
+    'idle-48h': { state: Number.isFinite(ageHours) ? (idle48h ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(ageHours) ? `head age=${ageHours.toFixed(1)}h` : 'head commit 시각 미관측' },
+    protected: { state: protectedState ? 'yes' : 'no', evidence: protectedLabel ? `보호 표지=${protectedLabel}` : '보호 표지 없음' },
+    'recent-commit': { state: Number.isFinite(latestCommit) ? (recentCommit ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(latestCommit) ? `last commit=${draft.latestCommitAt}; cutoff=09:30 KST` : 'head commit 시각 미관측' },
+    running: { state: running ? 'yes' : runNotRunning ? 'no' : 'unknown', evidence: running ? `run=${input.runStatus ?? 'elanous:running'}` : runNotRunning ? `종결 run=${input.runStatus}` : `run 상태 미관측${input.runStatus ? ` (${input.runStatus})` : ''}` },
+    'owner-confirmed': { state: input.ownerConfirmed === undefined ? 'unknown' : input.ownerConfirmed ? 'yes' : 'no', evidence: input.ownerConfirmed === undefined ? '소유자 출처 미관측' : input.ownerConfirmed ? '고유 카드 또는 활성 claim owner 확인' : '고유 소유자 없음' },
+  } satisfies DraftTriageAssessment['checks'];
+  const evidence = Object.values(checks).map((check) => check.evidence);
+  return { origin, cellId, cardId, gate: input.gate ?? 'unknown', review: input.review ?? 'unknown',
+    cellStatus: input.cellStatus ?? 'unknown', nextAction, checks, evidence };
 }
 
 export interface DraftTriageInput {

package/src/self-dev/fleet-reduce.ts

@@ -3,7 +3,7 @@
 //
 // 순서: 기준(origin/<base>)에서 임시 워크트리 → 조각 브랜치를 차례로 `merge --no-ff`
 //   → 충돌이면 «그 조각 ⊕ 충돌 파일»을 이름으로 대고 병합을 되돌린 뒤 멈춘다(추측으로 풀지 않는다)
-//   → 다 합쳐지면 `self gate --base <base>`(새 회귀만 빨강) → 통합 브랜치 푸시 → PR 하나(조각 PR 나열)
+//   → 다 합쳐지면 `self gate --local --base <base>`(새 회귀만 빨강) → 통합 브랜치 푸시 → PR 하나(조각 PR 나열)
 //   → 조각 PR 에 «통합 PR 로 대체됨» 코멘트(닫지는 않는다 — 사람 몫).
 // ⛔ 조각 PR 을 main 에 따로 병합하지 않는다 — 그건 `--auto-merge` 의 일이고 reduce 는 «하나로»다.
 
@@ -116,7 +116,8 @@ export async function reduceShards(opts: ReduceOptions): Promise<ReduceOutcome>
       // 게이트는 저장소 코드로 돈다 — 통합 워크트리에 의존성을 잇는다(설치 없이).
       const nm = join(opts.repoRoot, 'node_modules');
       if (existsSync(nm) && !existsSync(join(wt, 'node_modules'))) symlinkSync(nm, join(wt, 'node_modules'));
-      const g = run('bun', ['bin/elanous.mjs', 'self', 'gate', '--changed', '--base', `origin/${base}`], wt);   // 📏 `--changed` 가 없으면 rc 2 로 거절한다(첫 실물)
+      // This gate measures the local integration worktree; remote SSH availability is unrelated to the merge result.
+      const g = run('bun', ['bin/elanous.mjs', 'self', 'gate', '--local', '--changed', '--base', `origin/${base}`], wt);   // 📏 `--changed` 가 없으면 rc 2 로 거절한다(첫 실물)
       const tail = `${g.stdout}\n${g.stderr}`.trim().split('\n').slice(-6).join('\n');
       if (g.status !== 0) {
         debug.log('self-dev.reduce', 'gate-failed', { branch, merged: merged.length, rc: g.status });

package/src/self-dev/graph-front-nodes.ts

@@ -1,6 +1,10 @@
 import { debug } from '../debug/log.js';
+import type { GoalType } from '../self-implement/goal-author.js';
 import { frontObservationTemplate, visitBudgetOfVisits, type VisitBudgetReading } from '../self-implement/graph-authority.js';
 import { GRAPH_TEMPLATES_SOURCE, graphIdentityOf, pipelineNodeEntryPayload, type GraphTemplate } from '../self-implement/graph-templates.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
+import { journeyJoinFields } from './graph-journey-nodes.js';
+import { journeySpec, readJourneyEdge, recordJourneyEdge, type JourneyRoute } from './graph-journey-route.js';
 
 /** ⭐ RFC §5 «5단계» — 전반부(저작·플랜·분해) 노드를 그래프 관측에 «잇는다».
  *
@@ -51,6 +55,25 @@ export function resetFrontVisitCountsForTesting(now?: () => number): void {
   lastFrontVisitPruneMs = Number.NEGATIVE_INFINITY;
 }
 
+/** Record the actual front-half execution boundary, without controlling the stage. */
+export async function observeFrontNodeUnit<T>(node: FrontNodeId, runId: string | undefined, goalType: GoalType | undefined, execute: () => Promise<T>): Promise<T> {
+  const emit = (phase: 'enter' | 'exit'): void => {
+    if (!runId) return;
+    try {
+      const template = frontObservationTemplate(goalType);
+      const contractId = template.nodes.find((item) => item.nodeId === node)?.recipe ?? null;
+      const data = { graphId: template.graphId, nodeId: node, unit: node, contractId, phase };
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'graph.unit', data }, runLedgerDir()); }
+      catch { /* ledger failure cannot change execution */ }
+      try { debug.log('graph.unit', phase, { ...data, runId }); }
+      catch { /* debug failure cannot change execution */ }
+    } catch { /* template failure cannot change execution */ }
+  };
+  emit('enter');
+  try { return await execute(); }
+  finally { emit('exit'); }
+}
+
 function pruneIdleFrontVisitRuns(nowMs: number): void {
   if (nowMs - lastFrontVisitPruneMs < FRONT_VISIT_PRUNE_INTERVAL_MS) return;
   lastFrontVisitPruneMs = nowMs;
@@ -120,3 +143,92 @@ export function observeFrontNodeEntry(node: FrontNodeId, data: {
     });
   } catch { /* 판독 실패는 fail-soft — 예산은 관측이고 저작을 막지 않는다 */ }
 }
+
+/** GRAPH-AUTHOR-FAIL-EDGE — author 결과가 고르는 «앞단 결과 노드». ⛔ 런타임 값 — YAML 이 더한 노드를 시험이 센다. */
+export const AUTHOR_OUTCOME_NODE_IDS = ['re-ground', 'needs-human'] as const;
+
+/** author 노드의 결과 라벨 — implement-loop.yaml `from: author · on: outcome` 의 map 키와 «같은» 닫힌 집합. */
+export const AUTHOR_EXIT_OUTCOMES = ['ok', 're-authored', 'not-grounded', 'fail'] as const;
+export type AuthorExitOutcome = typeof AUTHOR_EXIT_OUTCOMES[number];
+
+export type FrontNodeExit =
+  | { readonly node: 'author'; readonly outcome: AuthorExitOutcome }
+  | { readonly node: 're-ground'; readonly outcome: 'retry' };
+
+export interface FrontNodeExitData {
+  /** 1 = 첫 저작 · 2 = 자동 재저작(re-ground 를 한 번 지난 뒤). */
+  readonly attempt: number;
+  /** 코드가 «실제로» 간 다음 노드 — 그래프 답과 다르면 graph-edge-taken 이 honored:false 로 남긴다. 없으면 그래프 답. */
+  readonly taken?: string;
+  readonly reason?: string;
+  readonly runId?: string;
+  readonly goalId?: string;
+  readonly goalType?: string;
+  readonly goalFile?: string;
+  /** 근거 카드 — needs-human 으로 갈 때 사람이 «무엇 때문에»를 다시 캐지 않게 막힘을 그대로 싣는다. */
+  readonly blockers?: readonly { readonly kind: string; readonly name: string; readonly detail?: string }[];
+}
+
+const EVIDENCE_DETAIL_CHARS = 400;
+
+/** 그래프가 고른 다음 노드에 «방문 예산»을 겹친다 — re-ground(max_visits 1)를 이미 지났으면 같은 결과의
+ *  두 번째는 re-ground 가 아니라 author 의 `fail` 출구(needs-human)로 간다. ⛔ 노드 이름·예산은 선언에서 읽는다. */
+function withVisitBudget(route: JourneyRoute, exit: FrontNodeExit, attempt: number): { readonly to: string | null; readonly budgetReason?: string } {
+  // ⛔ 예산을 겹치는 대상은 re-ground 뿐이다 — attempt-1 은 «re-ground 를 지난 횟수»이지 다른 노드의 방문 수가 아니다.
+  if (exit.node !== 'author' || route.to !== 're-ground') return { to: route.to };
+  const target = journeySpec({}).spec?.nodes.find((node) => node.nodeId === route.to);
+  const priorVisits = Math.max(0, attempt - 1);
+  if (target === undefined || priorVisits < target.maxVisits) return { to: route.to };
+  const exhausted = readJourneyEdge('author', 'fail');
+  return { to: exhausted.to, budgetReason: `${route.to}-visit-budget-exhausted (max_visits ${target.maxVisits})` };
+}
+
+/** ⭐ GRAPH-AUTHOR-FAIL-EDGE ① — 앞 노드의 «나감»을 결과와 함께 남긴다(진입만 있던 자리).
+ *  호출부(실행 경로): src/self-dev/ask-launch-flow.ts — 저작 끝(author ok · not-grounded · re-authored) ·
+ *    저작기 throw(author fail) · 자동 재저작 시작(re-ground retry).
+ *  🔎 관측: `self-implement` / `front-node-exit` ⊕ 같은 자리의 `graph-edge-taken`(from author|re-ground).
+ *  ⛔ 관측이지 제어가 아니다 — 다음 걸음은 여전히 코드가 정하고, 그래프 답과 다르면 honored:false 로 남는다.
+ *  ⛔ fail-soft — 관측 실패가 저작을 죽이지 않는다. */
+export function observeFrontNodeExit(exit: FrontNodeExit, data: FrontNodeExitData): JourneyRoute | null {
+  let recorded: JourneyRoute | null = null;
+  try {
+    const route = readJourneyEdge(exit.node, exit.outcome);
+    const budget = withVisitBudget(route, exit, data.attempt);
+    const graphRoute: JourneyRoute = { ...route, to: budget.to };
+    const taken = data.taken ?? budget.to ?? exit.outcome;
+    const reason = [budget.budgetReason, data.reason].filter((part): part is string => part !== undefined).join(' · ');
+    recordJourneyEdge(graphRoute, taken, reason.length > 0 ? reason : undefined);
+    recorded = graphRoute;
+    const payload = {
+      graphId: 'self-implement',
+      node: exit.node,
+      outcome: exit.outcome,
+      attempt: data.attempt,
+      to: budget.to,
+      taken,
+      honored: budget.to === null || budget.to === taken,
+      ...(reason.length > 0 ? { reason } : {}),
+      ...(data.runId === undefined ? {} : { runId: data.runId }),
+      ...(data.goalId === undefined ? {} : { goalId: data.goalId }),
+      ...(data.goalType === undefined ? {} : { goalType: data.goalType }),
+      ...(data.goalFile === undefined ? {} : { goalFile: data.goalFile }),
+      ...(data.blockers === undefined || data.blockers.length === 0 ? {} : {
+        evidenceCard: data.blockers.map((blocker) => ({
+          kind: blocker.kind, name: blocker.name,
+          ...(blocker.detail === undefined ? {} : { detail: blocker.detail.slice(0, EVIDENCE_DETAIL_CHARS) }),
+        })),
+      }),
+      phase: 'front',
+      graphTemplatesSource: GRAPH_TEMPLATES_SOURCE,
+      ...journeyJoinFields(),
+    };
+    try { debug.log('self-implement', 'front-node-exit', payload); }
+    catch { /* debug failure cannot change authoring */ }
+    // Pod 의 logs.db 는 Job 과 사라진다 — 원장에도 남겨 호스트가 NOT-GROUNDED 의 길을 사후에 읽게 한다.
+    if (data.runId !== undefined) {
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: data.runId, event: 'front-node-exit', data: payload }, runLedgerDir()); }
+      catch { /* ledger failure cannot change authoring */ }
+    }
+  } catch { /* 관측은 fail-soft — 저작을 죽이지 않는다 */ }
+  return recorded;
+}