elanous 0.2.23 → 0.2.25

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

@@ -4,6 +4,7 @@ import { decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, l
 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;
@@ -60,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. */
@@ -114,9 +121,25 @@ export interface DraftSweepResult {
    * harvestable (review PASS and gate pass), and blocked (must-fix remains).
    */
   daily?: DraftSweepDaily;
+  /**
+   * Same-lineage rule outcomes this tick (DRAFT-SWEEP-LINEAGE-HARVESTABLE): closes it decided (harvestable among them)
+   * and every candidate it let fall through to the older rules, by reason.
+   */
+  lineage?: DraftSweepLineageCounts;
   error?: string;
 }
 
+export interface DraftSweepLineageCounts {
+  closed: number;
+  harvestableClosed: number;
+  fallThrough: Record<string, number>;
+}
+
+/** A review counts as passed only on an observed PASS with no must-fix left. */
+function reviewPassed(posture: SweepReviewGate | undefined): boolean {
+  return posture?.review === 'pass' && posture.mustFix !== true;
+}
+
 /** Daily old-draft census. `date` is the sweep clock's UTC calendar day. */
 export interface DraftSweepDaily {
   readonly date: string;
@@ -138,6 +161,19 @@ export interface DraftMetrics {
   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');
@@ -444,6 +480,7 @@ 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;
@@ -596,9 +633,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,
@@ -731,6 +785,13 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
+  const lineageCounts: DraftSweepLineageCounts = { closed: 0, harvestableClosed: 0, fallThrough: {} };
+  result.lineage = lineageCounts;
+  // 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));
+    return reviewGate.get(pr.number);
+  };
   for (const listedDraft of drafts) {
     const draft = { ...listedDraft, labels: [...listedDraft.labels], latestFileChanges: latestFileChanges.get(listedDraft.number) };
     let releasedThisTick = false;
@@ -842,6 +903,95 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     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.
+    // DRAFT-SWEEP-LINEAGE-HARVESTABLE (10-12): a harvestable draft is no longer skipped — the skip left 70+ harvestable
+    // 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) {
+      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) => {
+          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 */ }
+        };
+        // 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).
+        let harvestProtection: string | undefined;
+        if (harvestable) {
+          if (!adapters.getReviewGate) harvestProtection = 'lineage-harvestable-review-unobserved';
+          else {
+            try {
+              const [oldPosture, newPosture] = [await postureFor(draft), await postureFor(lineageNewer)];
+              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);
+        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 (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;
+            lineageCounts.closed += 1;
+            if (harvestable) lineageCounts.harvestableClosed += 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;
+                lineageCounts.closed -= 1;
+                if (harvestable) lineageCounts.harvestableClosed -= 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,
@@ -949,6 +1099,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
   }
   timing('decide', drafts.length);
+  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;
   // `closed` stays «closed by this sweep»; replay closes only consume the shared cap (alreadyClosed).

package/src/self-dev/fabric-decompose-adapter.ts

@@ -1,4 +1,3 @@
-import { tierModel } from '../llm/model-defaults.js';
 import { statSync } from 'node:fs';
 import { resolve, sep } from 'node:path';
 import {
@@ -9,6 +8,7 @@ import {
 } from '../autopilot/mission-rfc-author.js';
 import {
   DEFAULT_MAX_TASKS,
+  decomposeModel,
   decomposeSelfDevGoal,
   type SelfDevDecomposeLlm,
   type SelfDevDecomposeOptions,
@@ -70,9 +70,16 @@ export type FabricDecomposeRequestResult =
   | { status: 'grounding-failed'; message: string; cause: unknown }
   | { status: 'grounding-empty'; message: string; grounding: GoalAuthoringGroundingResult };
 
+/**
+ * Default fabric resolve seam — lazy `streamLLM` wire. The model comes from the
+ * shared planning-role selector `decomposeModel` (src/self-dev/decompose.ts),
+ * so the review env `ELANOUS_PR_REVIEW_MODEL` cannot retarget fabric
+ * decomposition (ROLE-RELAY-SPLIT).
+ */
 async function defaultFabricResolve(prompt: string): Promise<string> {
   const { streamLLM } = await import('../llm.js');
-  const model = process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('best');
+  const { model, source } = decomposeModel();
+  debug.log('self-dev.decompose', 'model', { model, source });
   return streamLLM([{ role: 'user', content: prompt }], () => {}, { model, reasoningEffort: 'low' });
 }
 

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';
+}

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

@@ -421,6 +421,9 @@ export async function runSelfOrchestrateCliCommand(
       await recordRoundPrs(results);
       results = await superviseRun({
         initial: results,
+        // The add-repair-task branch below runs each authored review-oscillation repair goal as that goal's new
+        // feature (a fresh piece, same goal id) — the supervisor records the repair text, so a second oscillation stops.
+        repairGoalExecution: true,
         limits,
         enrich: (rs) => backfillDecomposeProposals([...rs], deps),
         onDecision: (decision) => {
@@ -431,9 +434,28 @@ export async function runSelfOrchestrateCliCommand(
         onRound: (rs) => { try { baseRuntime.checkpoint?.([...rs]); } catch { /* fail-open */ } },
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
-        rerun: async (previous) => {
+        rerun: async (previous, invocation) => {
           let addedRepairIds: string[] = [];
-          if (currentDecision?.action === 'add-repair-task') {
+          // A requested repair that cannot be bound to exactly one goal is held (not relaunched with the old strategy).
+          const unrepairedHold: string[] = [];
+          if (invocation.repairGoals) {
+            const replacements = new Map<SelfDevGoal, string>();
+            for (const [taskId, repairGoal] of Object.entries(invocation.repairGoals)) {
+              const source = previous.find((result) => result.taskId === taskId);
+              const matches = source ? currentGoals.filter((goal) => resumeKey(goal.feature) === resumeKey(source.feature)) : [];
+              if (matches.length === 1 && !replacements.has(matches[0]!)) replacements.set(matches[0]!, repairGoal);
+              else unrepairedHold.push(taskId);
+            }
+            currentGoals = currentGoals.map((goal) => replacements.has(goal) ? { ...goal, feature: replacements.get(goal)! } : goal);
+            spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
+            try {
+              debug.log('self-dev.supervisor', 'oscillation-repair.executed', {
+                surface: 'orchestrate', replaced: replacements.size, requested: Object.keys(invocation.repairGoals).length, held: unrepairedHold,
+              });
+            } catch { /* fail-open */ }
+          }
+          // A review-oscillation decision attaches only its authored repair goals (above) — never deliverable fragments too.
+          if (currentDecision?.action === 'add-repair-task' && !currentDecision.oscillation) {
             const appended = appendRepairFragments(currentGoals, currentDecision.classifications, {
               seenFingerprints: repairFingerprints,
               addedCount: repairFragmentsAdded,
@@ -487,7 +509,7 @@ export async function runSelfOrchestrateCliCommand(
           baseRuntime = runtimeWithParentRequest();
           // ⛔⭐ 판정이 「사람이 볼 것」이라 한 조각은 집행이 다시 돌리지 않는다 — 판정과 집행이 갈리면
           //   `pr-opened` 조각이 duplicate-risk 로 재실행돼 PR 이 겹친다(2026-09-25 실측).
-          const resumeHold = currentDecision?.needsHuman ?? [];
+          const resumeHold = [...new Set([...(currentDecision?.needsHuman ?? []), ...unrepairedHold])];
           // The engine's resume lookup is last-result-wins for each normalized feature.
           // Use that exact predecessor, not any earlier task sharing the same feature.
           const selectedPrior = new Map(previous.map((result) => [resumeKey(result.feature), result.taskId]));

package/src/self-dev/orchestrate.ts

@@ -23,6 +23,7 @@ import { parentUnlandedProgressLine } from './run-supervisor.js';
 import { mkdirSync, openSync, writeFileSync, closeSync, renameSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { goalPathFromArgv, launchRegistryDir, removeLaunchBinding, writeLaunchBinding } from '../harness/launch-registry.js';
+import { adoptRunCard } from '../task-agent/run-adopt.js';
 import { availableParallelism, cpus } from 'node:os';
 import { selfDevRunsDir } from './run-store.js';
 import { HARNESS_RUN_ID_ENV, normalizeRunId } from '../harness/harness-space.js';
@@ -369,6 +370,11 @@ export type TriageAction =
   | 'decompose-and-retry'
   /** 기존 조각을 치환하거나 재실행하지 않고 수리 조각을 추가한다. */
   | 'add-repair-task'
+  /**
+   * main 정합(LLM 충돌 해결)이 막힌 조각을 «조각당 한 번» 최신 main 위에서 다시 건다.
+   * 보존 가지는 지우지 않고 재발사 골의 참고로만 쓴다. 두 번째부터는 `needs-human`.
+   */
+  | 'relaunch-on-main'
   /** 실패가 아니었다(전송 불일치) — 건드리지 않는다. */
   | 'no-action'
   /** 모른다 — 사람이 본다. */
@@ -386,7 +392,11 @@ export interface FailureClassification {
 }
 
 /** 순수: 분류 → 다음 행동. ⛔ 한 자리에서만 정한다(소비자가 각자 매핑하면 갈린다). */
-export function triageActionFor(kind: FailureKind): TriageAction {
+export function triageActionFor(
+  kind: FailureKind,
+  /** `main-sync-blocked` 만 읽는다 — 이 조각의 재발사 한 번을 이미 썼으면 true. */
+  options: { mainSyncRelaunchSpent?: boolean } = {},
+): TriageAction {
   switch (kind) {
     case 'transient': return 'rerun';
     case 'blocked-upstream': return 'rerun-after-upstream';
@@ -396,14 +406,22 @@ export function triageActionFor(kind: FailureKind): TriageAction {
     case 'deliverable-broken':
     case 'oversized-goal': return 'add-repair-task';
     case 'false-failure': return 'no-action';
+    case 'main-sync-blocked': return options.mainSyncRelaunchSpent === true ? 'needs-human' : 'relaunch-on-main';
     case 'awaiting-human':
     case 'parent-unlanded':
-    case 'main-sync-blocked':
     case 'provider-rejected': return 'needs-human';
     default: return 'needs-human';
   }
 }
 
+/**
+ * main 정합 충돌로 멈춘 결과만 «최신 main 위 재발사» 후보다. harvestable 이라도 다른 단계(timed-out 등)에서
+ * 멈춘 결과는 후보가 아니다 — 지금처럼 사람이 수확한다.
+ */
+export function isMainSyncRelaunchCandidate(result: Pick<SelfDevJobResult, 'stage'>): boolean {
+  return result.stage === 'merge-conflict';
+}
+
 const LEDGER_FAILURE_KIND: Partial<Record<AbandonedClassification, FailureKind>> = {
   'implementation-deficit': 'unconverged',
   'report-deficit': 'unconverged',
@@ -588,6 +606,8 @@ export function failureFromDeployFindings(
 export function classifyFailures(
   results: SelfDevJobResult[],
   queryPreflight?: PreflightLogQuery,
+  /** 이 조각이 main 정합 재발사 한 번을 이미 썼나 — 생략은 «감독 없음» 이라 종전대로 needs-human. */
+  mainSyncRelaunchSpent?: (result: SelfDevJobResult) => boolean,
 ): FailureClassification[] {
   return results.flatMap((result) => {
     const preflightIdentifiers = [...new Set([result.runId, result.taskId].filter((id): id is string => Boolean(id)))];
@@ -603,7 +623,10 @@ export function classifyFailures(
       taskId: result.taskId,
       stage: result.stage ?? null,
       kind,
-      action: triageActionFor(kind),
+      action: triageActionFor(kind, {
+        // 생략 = 감독 없이 도는 경로(재발사할 주체가 없다) — 종전대로 needs-human. 재발사는 감독이 이력으로 셀 때만.
+        mainSyncRelaunchSpent: !isMainSyncRelaunchCandidate(result) || !mainSyncRelaunchSpent || mainSyncRelaunchSpent(result) === true,
+      }),
       ...(awaitingHuman ?? failureObservationFields(error?.code ?? 'UNKNOWN', error?.message ?? '')),
     }];
   });
@@ -651,8 +674,12 @@ export function triageRun(
   hasUnmeasuredDeliverables = false,
   /** Optional injected lookup of launch preflight observations; absence remains unknown. */
   queryPreflight?: PreflightLogQuery,
+  /** 이 조각이 main 정합 재발사 한 번을 이미 썼나 — 생략은 «감독 없음» 이라 종전대로 needs-human. */
+  mainSyncRelaunchSpent?: (result: SelfDevJobResult) => boolean,
 ): {
   classifications: FailureClassification[];
+  /** ⭐ main 정합이 막힌 조각 중 «첫 번» — 사람 수확 대신 최신 main 위에서 다시 건다. */
+  relaunchOnMain: string[];
   /** 그대로 다시 걸면 되는 조각(일시적·상류대기). */
   rerunnable: string[];
   /** 다시 걸 수는 있으나 같은 결과일 수 있는 조각(수렴 실패). */
@@ -678,21 +705,23 @@ export function triageRun(
     failureFromDeployFindings(taskId, observation.target, observation.findings));
   const classifications = [
     ...deployClassifications,
-    ...classifyFailures(results, queryPreflight),
+    ...classifyFailures(results, queryPreflight, mainSyncRelaunchSpent),
   ];
   const pick = (a: TriageAction) => classifications.filter((c) => c.action === a).map((c) => c.taskId);
   const rerunnable = [...pick('rerun'), ...pick('rerun-after-upstream')];
   const reworkable = pick('rework');
   const decomposable = pick('decompose-and-retry');
   const repairable = [...new Set(pick('add-repair-task'))];  // ⛔ finding 이 여럿이면 같은 taskId 가 겹친다
+  const relaunchOnMain = [...new Set(pick('relaunch-on-main'))];
   return {
     classifications,
+    relaunchOnMain,
     rerunnable,
     reworkable,
     decomposable,
     repairable,
     needsHuman: pick('needs-human'),
-    actionable: rerunnable.length + reworkable.length + decomposable.length + repairable.length > 0,
+    actionable: rerunnable.length + reworkable.length + decomposable.length + repairable.length + relaunchOnMain.length > 0,
     deliverableUnmeasured,
   };
 }
@@ -897,7 +926,11 @@ export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDi
     const cwd = process.cwd();
     const goalPath = goalPathFromArgv(process.argv, cwd);
     writeLaunchBinding(runId, { pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0,
-      cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir) }, registryDir);
+      cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir),
+      ...(process.env.ELANOUS_POD_NAME ? { podName: process.env.ELANOUS_POD_NAME } : {}),
+      ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}) }, registryDir);
+    try { adoptRunCard({ runId, cwd, goalPath, runsDir, env: process.env }); }
+    catch (error) { try { debug.log('task-agent', 'run-adopt-failed', { runId, error: String(error) }); } catch { /* launch must continue */ } }
   }
   return pidPath;
 }
@@ -1381,6 +1414,8 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.completionDisposition ? { completionDisposition: disp.completionDisposition } : {}),
           ...(disp?.failureClassification ? { failureClassification: disp.failureClassification } : {}),
           ...(disp?.providerErrors ? { providerErrors: disp.providerErrors } : {}),
+          ...(disp?.rework ? { rework: disp.rework } : {}),
+          ...(disp?.mustFix ? { reviewMustFix: disp.mustFix } : {}),
           ...(goalCauseObservedFromFailureClassification(disp?.failureClassification) === true
             ? { goalCauseObserved: true } : {}),
           ...(disp?.runId ? { runId: disp.runId } : {}),