elanous 0.2.13 → 0.2.15

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

@@ -35,14 +35,15 @@ import type { DocumentReferenceStatus } from '../self-implement/self-implement-r
 import type { SelfDevGoal, OrchestrateSelfDevOptions, SelfDevJobResult } from './orchestrate.js';
 import { launchCapabilityObservation, resolveLaunchCapabilities } from './launch-capabilities.js';
 import { lookupEntrance, type EntranceId } from './entrance-registry.js';
+import { resolveLaunchStamp } from '../harness/launch-stamp.js';
 import type { IngestionEntry } from '../agent-substrate/execution/ingestion-policy.js';
 import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
-import { addSelfDevRunParticipant, saveSelfDevRun } from './run-store.js';
+import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-store.js';
 import { getUserConfig, resolveRoleLlm } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
-import { buildReviewProviderAttempts, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
+import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
 import { harnessTargetOptions, resolveHarnessTarget, revalidateHarnessTarget, type HarnessTargetResolution } from '../self-implement/harness-target-options.js';
 import { provisionRepository, type RepoProvisionResult } from '../self-implement/repo-provision.js';
@@ -609,6 +610,7 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
     ...(s.branchName ? { branchName: s.branchName } : {}),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),
+    launch: resolveLaunchStamp({ entrance: plan.entrance, queueId: process.env.ELANOUS_HARNESS_QUEUE_LAUNCH }),
   };
 }
 
@@ -1093,10 +1095,12 @@ export async function buildDefaultSelfImplementSeams(
     provider: inferProviderFromModel(model) ? getProvider(model) : undefined,
     label,
   });
+  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary');
   const reviewAttempts = buildReviewProviderAttempts(
-    reviewAttemptForModel(reviewModel, 'primary'),
-    reviewFallbackModels.map((model) => reviewAttemptForModel(model, model)),
-  );
+    primaryReviewAttempt,
+    [...reviewFallbackModels, defaultReviewFallbackModel(primaryReviewAttempt.provider?.name)]
+      .map((model) => reviewAttemptForModel(model, model)),
+  ).slice(0, 2);
   const defaultApiReview = async (prompt: string): Promise<string> => {
     const r = await runReviewWithFallback(
       reviewAttempts,
@@ -1718,7 +1722,11 @@ export async function runDevPipeline(spec: DevPipelineSpec, deps: DevPipelineDep
   if (spec.runId) {
     const runIdSource = spec.runIdSource ?? resolveRunIdentity({ explicit: spec.runId }).source;
     const now = Date.now();
-    saveSelfDevRun({ runId: spec.runId, createdAt: now, updatedAt: now, results: [], pid: process.pid });
+    const seat = process.env.ELANOUS_HARNESS_SEAT;
+    const pidStart = processBirthId(process.pid);
+    saveSelfDevRun({ runId: spec.runId, createdAt: now, updatedAt: now, results: [], pid: process.pid,
+      ...(pidStart ? { pidStart } : {}),
+      ...(seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? { seat } : {}) });
     addSelfDevRunParticipant(spec.runId, {
       id: `process:${process.pid}`,
       kind: 'process',

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

@@ -1,6 +1,6 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
+import { decideDraft, sameGoalPr, type DraftTriagePr } from './draft-triage-rules.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
@@ -31,6 +31,20 @@ export interface DraftSweepAdapters {
   hasFinalRunResult?(draft: SweepDraft, repository: string): Promise<boolean | undefined>;
   /** Per-file last change on the draft branch; undefined means file coverage is unverified. */
   getLatestFileChanges?(draft: SweepDraft, repository: string): Promise<Readonly<Record<string, string>> | undefined>;
+  /** Optional merge-time file inventory for the existing all-files-landed decision. */
+  getPrFiles?(repository: string, number: number): Promise<readonly string[] | undefined>;
+  /**
+   * Review and gate posture for the daily count. Omitted means unknown — not harvestable and not blocked.
+   * `review: 'pass'` is a review PASS; `mustFix` means must-fix remains; `gate: 'pass'` is a green gate.
+   */
+  getReviewGate?(draft: SweepDraft, repository: string): Promise<SweepReviewGate | undefined>;
+}
+
+/** Review PASS and gate posture used only by the daily old-draft count. */
+export interface SweepReviewGate {
+  readonly review?: 'pass' | 'fail';
+  readonly mustFix?: boolean;
+  readonly gate?: 'pass' | 'fail';
 }
 
 export interface DraftSweepOptions {
@@ -65,9 +79,23 @@ export interface DraftSweepResult {
   claimed?: number;
   /** Running claims older than the idle window, including those kept by liveness. */
   claimExpired?: number;
+  /**
+   * One line per sweep: harness drafts older than 24h, split into closable (a same-goal landing exists),
+   * harvestable (review PASS and gate pass), and blocked (must-fix remains).
+   */
+  daily?: DraftSweepDaily;
   error?: string;
 }
 
+/** Daily old-draft census. `date` is the sweep clock's UTC calendar day. */
+export interface DraftSweepDaily {
+  readonly date: string;
+  readonly over24h: number;
+  readonly closable: number;
+  readonly harvestable: number;
+  readonly blocked: number;
+}
+
 const stateLabels = PR_LABELS.filter((label) => label.axis === 'state');
 const label = (action: 'mark-stalled' | 'close', name?: string): string => {
   const match = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === action && (name === undefined || entry.name.endsWith(name)));
@@ -84,6 +112,80 @@ const PAGE_SIZE = 100;
 /** At most this many closes per tick, so a wrong rule cannot close everything at once. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
 
+/** Post-merge shortcut: only the existing superseded-by decision can authorize a close. */
+export async function supersedeDraftsOnMerge(input: {
+  repository: string;
+  merged: SweepMergedPr & { createdAt: string; mergedAt: string };
+  adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listLiveBranches' | 'getRunStatus' | 'setLabels' | 'closeDraft'>
+    & Pick<Partial<DraftSweepAdapters>, 'getLatestFileChanges' | 'getPrFiles'>;
+}): Promise<{ closed: number[]; kept: number[] }> {
+  const { repository, merged, adapters } = input;
+  const closed: number[] = [];
+  const kept: number[] = [];
+  let drafts: SweepDraft[] = [];
+  let error: string | undefined;
+  const failed: number[] = [];
+  let closeAttempts = 0;
+  try {
+    const [listedDrafts, liveBranches] = await Promise.all([
+      collectPages((page, size) => adapters.listDrafts(page, size, repository)),
+      adapters.listLiveBranches(repository),
+    ]);
+    drafts = listedDrafts;
+    if (!liveBranches || !Number.isInteger(merged.number) || !merged.branch || !merged.title
+      || !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');
+    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);
+    const landed = { ...merged, changedFiles: mergedFiles };
+    for (const draft of drafts) {
+      if (draft.number !== merged.number && draft.branch.startsWith('self-impl/') && !liveBranches.has(draft.branch)
+        && Date.parse(draft.createdAt) < Date.parse(merged.mergedAt)) {
+        statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
+        if (draft.changedFiles?.length && adapters.getLatestFileChanges) {
+          latestChanges.set(draft.number, await adapters.getLatestFileChanges(draft, repository));
+        }
+      }
+    }
+    for (const listedDraft of drafts) {
+      const draft = { ...listedDraft, latestFileChanges: latestChanges.get(listedDraft.number) };
+      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);
+        continue;
+      }
+      const decision = decideDraft({ draft, runStatus: statuses.get(draft.number),
+        mergedTwins: [landed], liveBranches, ageHours: NaN });
+      if (decision.action !== 'close' || !decision.reason.startsWith(`superseded-by #${merged.number}`)
+        || PR_LABELS.filter((entry) => entry.axis === 'state' && draft.labels.includes(entry.name)).length > 1
+        || closeAttempts >= DRAFT_SWEEP_CLOSE_CAP) {
+        kept.push(draft.number);
+        continue;
+      }
+      closeAttempts += 1;
+      const remove = stateLabels.filter((entry) => draft.labels.includes(entry.name) && entry.name !== supersededLabel).map((entry) => entry.name);
+      try {
+        // Label first: a failed label write must never strand a closed, unlabelled PR outside open-draft sweeps.
+        if (!draft.labels.includes(supersededLabel)) await adapters.setLabels(repository, draft.number, { add: supersededLabel, remove });
+        await adapters.closeDraft(repository, draft.number,
+          `Draft sweep: superseded-by #${merged.number} (https://github.com/${repository}/pull/${merged.number}). Branch preserved.`);
+        closed.push(draft.number);
+      } catch (failure) {
+        kept.push(draft.number);
+        failed.push(draft.number);
+        error = String(failure);
+      }
+    }
+  } catch (failure) {
+    error = String(failure);
+    kept.push(...drafts.map((draft) => draft.number).filter((number) => !closed.includes(number) && !kept.includes(number)));
+  }
+  debug.log('drafts.cleanup', 'superseded-on-merge', { merged: merged.number, closed, kept, ...(failed.length ? { failed } : {}), ...(error ? { error } : {}) });
+  return { closed, kept };
+}
+
 async function collectPages<T>(fetch: (page: number, perPage: number) => Promise<readonly T[]>): Promise<T[]> {
   const rows: T[] = [];
   for (let page = 1; page <= 100; page++) {
@@ -95,6 +197,46 @@ async function collectPages<T>(fetch: (page: number, perPage: number) => Promise
   throw new Error('PR listing exceeded pagination limit');
 }
 
+/** First line of a failure, with no stack — the draft-cleanup loop log shows this line as-is. */
+export function sweepFailureReason(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  const line = message.split(/\r?\n/).map((part) => part.trim()).find((part) => part.length > 0 && !/^\s*at\s/.test(part));
+  return line && line.length > 0 ? line : 'sweep failed';
+}
+
+function harnessDraft(draft: SweepDraft): boolean {
+  return draft.branch.startsWith('self-impl/') || draft.labels.some((name) => name.startsWith('elanous:'));
+}
+
+/**
+ * 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,
+ * and blocked when must-fix remains. Unknown review/gate is neither harvestable nor blocked.
+ */
+export function draftSweepDaily(
+  drafts: readonly SweepDraft[],
+  merged: readonly SweepMergedPr[],
+  now: Date,
+  reviewGate: ReadonlyMap<number, SweepReviewGate | undefined>,
+): DraftSweepDaily {
+  const cutoff = now.getTime() - STALLED_DRAFT_HOURS * 3_600_000;
+  let over24h = 0;
+  let closable = 0;
+  let harvestable = 0;
+  let blocked = 0;
+  for (const draft of drafts) {
+    if (!harnessDraft(draft)) continue;
+    const created = Date.parse(draft.createdAt);
+    if (!Number.isFinite(created) || created > cutoff) continue;
+    over24h += 1;
+    if (merged.some((pr) => pr.number !== draft.number && sameGoalPr(draft, pr))) closable += 1;
+    const posture = reviewGate.get(draft.number);
+    if (posture?.mustFix === true) blocked += 1;
+    else if (posture?.review === 'pass' && posture.gate === 'pass') harvestable += 1;
+  }
+  return { date: now.toISOString().slice(0, 10), over24h, closable, harvestable, blocked };
+}
+
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
 export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
   const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
@@ -105,10 +247,12 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   };
   const finish = (): DraftSweepResult => {
     debug.log('drafts.cleanup', 'summary', result.counts);
+    if (result.daily) debug.log('harness.drafts', 'daily', result.daily);
+    if (!result.complete && result.error) debug.log('drafts.cleanup', 'failed', { reason: sweepFailureReason(result.error) });
     return result;
   };
-  let drafts: SweepDraft[];
-  let merged: SweepMergedPr[];
+  let drafts: SweepDraft[] = [];
+  let merged: SweepMergedPr[] = [];
   let liveBranches: ReadonlySet<string> | undefined;
   try {
     [drafts, merged, liveBranches] = await Promise.all([
@@ -120,7 +264,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     if (drafts.some((pr) => !Number.isInteger(pr.number) || !pr.branch || !Array.isArray(pr.labels) || !Number.isFinite(Date.parse(pr.createdAt)))
       || merged.some((pr) => !Number.isInteger(pr.number) || !pr.branch)) throw new Error('Invalid PR inventory');
   } catch (error) {
-    result.error = String(error);
+    result.error = sweepFailureReason(error);
+    if (drafts.length > 0) result.daily = draftSweepDaily(drafts, merged, now, new Map());
     return finish();
   }
   let statuses: Map<number, string | undefined>;
@@ -142,9 +287,19 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       }
     }
   } catch (error) {
-    result.error = String(error);
+    result.error = sweepFailureReason(error);
     return finish();
   }
+  let reviewGate = new Map<number, SweepReviewGate | undefined>();
+  if (adapters.getReviewGate) {
+    try {
+      for (const draft of drafts) reviewGate.set(draft.number, await adapters.getReviewGate(draft, repository));
+    } catch (error) {
+      result.error = sweepFailureReason(error);
+      return finish();
+    }
+  }
+  result.daily = draftSweepDaily(drafts, merged, now, reviewGate);
   result.complete = true;
   let closes = 0;
   let unobserved = 0;
@@ -254,7 +409,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.`
-          : `Draft sweep: ${decision.reason}. Branch preserved.`);
+          : `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.`);
       }
       entry.applied = labelsChanged || action === 'close';
     } catch (error) {

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

@@ -38,6 +38,21 @@ const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
 const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
 export const branchStem = (branch: string): string | undefined => /^self-impl\/(.+)-[a-f0-9]{8}-r[a-f0-9]+$/i.exec(branch)?.[1];
 const slot = (body?: string): string | undefined => /^칸:\s*(.+?)\s*$/m.exec(body ?? '')?.[1];
+const goalText = (body?: string): string | undefined => /^골:\s*(\S.*?)\s*$/m.exec(body ?? '')?.[1];
+// Auto titles name only files («src/harness: harness-queue.ts») — different goals share them, so they never identify a goal.
+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. */
+export function sameGoalPr(a: DraftTriagePr, b: DraftTriagePr): boolean {
+  const idA = goalId(a.branch), idB = goalId(b.branch);
+  if (idA && idB) return idA === idB;
+  const textA = goalText(a.body), textB = goalText(b.body);
+  if (textA && textB) return textA === textB;
+  if (!a.title || a.title !== b.title || isAutoTitle(a.title)) return false;
+  const stemA = branchStem(a.branch);
+  return Boolean(stemA && a.branch.startsWith('self-impl/') && b.branch.startsWith('self-impl/') && stemA === branchStem(b.branch));
+}
 const referencesDraft = (text: string, number: number): boolean =>
   new RegExp(`(?:\\(수확\\s*#${number}\\s*\\)|\\bsuperseded\\s*#${number}(?!\\d))`, 'i').test(text);
 const landingCommentReferencesDraft = (text: string, number: number): boolean =>
@@ -55,28 +70,30 @@ export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHour
     return { action: 'keep', reason: 'live' };
   }
   const lineage = goalId(draft.branch);
-  const twin = mergedTwins.find((pr) => pr.number !== draft.number && (
-    (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
-  ));
-  if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  const draftSlot = slot(draft.body);
   const stem = branchStem(draft.branch);
+  const compatible = (pr: DraftTriagePr): boolean =>
+    !(lineage && goalId(pr.branch) && goalId(pr.branch) !== lineage)
+    && !(draftSlot && slot(pr.body) && slot(pr.body) !== draftSlot);
+  const twin = mergedTwins.find((pr) => pr.number !== draft.number && compatible(pr) && sameGoalPr(draft, pr));
+  if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
   const createdAt = Date.parse(draft.createdAt ?? '');
   const newer = stem && draft.title && Number.isFinite(createdAt) ? openDrafts
-    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem
+    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem && sameGoalPr(draft, pr)
       && Number.isFinite(Date.parse(pr.createdAt ?? '')) && Date.parse(pr.createdAt!) > createdAt)
     .sort((a, b) => Date.parse(b.createdAt!) - Date.parse(a.createdAt!) || b.number - a.number)[0] : undefined;
   if (newer) return { action: 'close', reason: `duplicate-of-open #${newer.number}` };
-  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && (
+  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && compatible(pr) && (
     [pr.mergeCommitMessage, pr.body].some((text) => text && referencesDraft(text, draft.number))
     || pr.landingVerifiedComments?.some((text) => landingCommentReferencesDraft(text, draft.number))
   ));
   if (harvest) return { action: 'close', reason: `superseded-by #${harvest.number} (harvest #${draft.number})` };
   const created = Date.parse(draft.createdAt ?? '');
   const files = draft.changedFiles;
-  const draftSlot = slot(draft.body);
   const later = mergedTwins.filter((pr) => pr.number !== draft.number && Number.isFinite(created)
     && Number.isFinite(Date.parse(pr.mergedAt ?? '')) && Date.parse(pr.mergedAt!) > created
-    && ((lineage && goalId(pr.branch) === lineage) || (draftSlot && slot(pr.body) === draftSlot)));
+    && compatible(pr) && ((lineage && goalId(pr.branch) === lineage)
+      || (draftSlot && slot(pr.body) === draftSlot) || (stem && branchStem(pr.branch) === stem)));
   if (files?.length && files.every((file) => {
     const changed = Date.parse(draft.latestFileChanges?.[file] ?? '');
     return Number.isFinite(changed) && changed >= created && later.some((pr) =>

package/src/self-dev/orchestrate.ts

@@ -260,12 +260,23 @@ export interface SelfDevJobResult {
    *  (merged / pr-opened / gate-failed / review-blocked / pr-declined). */
   stage?: string;
   branch?: string;
+  /** Child confirmed the finished implementation was pushed for manual harvest. */
+  harvestable?: true;
   worktreePath?: string;
   prUrl?: string;
   prNumber?: number;
   merged?: boolean;
   /** Child commit SHA, when observed by the Pod/host. */
   checkedHeadCommit?: string;
+  /**
+   * This run's own `--base` (not main). A non-main completion mode
+   * (worktree-only, draft, `--base` other than main) lands commits here.
+   */
+  base?: string;
+  /** Child finished with GOAL-COMPLETE (`ok=true`). Distinct from a main merge. */
+  ok?: boolean;
+  /** Commits this child added against its own `--base`. 0 is not completion progress. */
+  commitsAheadOfBase?: number;
   /** A dependency is done but its result is not on main; no child was launched. */
   blockReason?: 'parent-unlanded';
   parentPrNumber?: number;
@@ -405,6 +416,7 @@ export type ResumeDisposition = 'skip' | 'rerun' | 'rerun-duplicate-risk';
  */
 export function classifyResumeDisposition(result: SelfDevJobResult): ResumeDisposition {
   if (hasDelivered(result)) return 'skip';
+  if (result.harvestable === true && result.branch) return 'skip';
   if (result.stage === 'pr-opened') return 'rerun-duplicate-risk';
   if (result.merged === false) return 'rerun';
   if (result.status !== 'done') return 'rerun';
@@ -621,6 +633,7 @@ export function classifyFailure(
   ) {
     return 'awaiting-human';
   }
+  if (result.harvestable === true && result.branch) return 'main-sync-blocked';
   if (result.status === 'done' && !hasDelivered(result)) return convergedFailureKind();
   // ⭐ 상류가 죽어 «취소»된 조각 — 종전엔 status 가 failed 도 done 도 아니라 null 로 사라졌다.
   //   ⛔ 이것을 못 보면 「무엇이 상류를 기다리는가」를 슈퍼바이저가 영영 모른다.
@@ -1479,6 +1492,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(resumeDisposition ? { resumeDisposition } : {}),
           ...(disp?.stage ? { stage: disp.stage } : {}),
           ...(disp?.branch ? { branch: disp.branch } : {}),
+          ...(disp?.harvestable === true && disp.branch ? { harvestable: true } : {}),
           ...(disp?.worktreePath ? { worktreePath: disp.worktreePath } : {}),
           ...(disp?.prUrl ? { prUrl: disp.prUrl } : {}),
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
@@ -1526,7 +1540,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
         const rm = opts.removeWorktree ?? defaultRemoveWorktree;
         let removed = 0;
         for (const r of out) {
-          if (!r.worktreePath || r.prUrl) continue;
+          if (!r.worktreePath || r.prUrl || r.harvestable) continue;
           try { rm(r.worktreePath); removed++; } catch { /* fail-soft */ }
         }
         if (removed > 0) debug.log('self-dev.orchestrate', 'teardown', { removed });

package/src/self-dev/review-provider-fallback.ts

@@ -73,13 +73,18 @@ export function buildReviewProviderAttempts(
   const out: ReviewProviderAttempt[] = [primary];
   const seen = new Set([primary.model]);
   for (const f of fallbacks) {
-    if (!f.model.trim() || seen.has(f.model)) continue;
+    if (!f.model.trim() || seen.has(f.model) || (primary.provider && f.provider?.name === primary.provider.name)) continue;
     seen.add(f.model);
     out.push(f);
   }
   return out;
 }
 
+/** A distinct provider is available even when the optional config list is empty. */
+export function defaultReviewFallbackModel(primaryProvider?: string): string {
+  return resolveModelAlias(primaryProvider === 'grok' ? 'claude' : 'grok')!;
+}
+
 export interface ReviewFallbackObservation {
   readonly attempt: number;
   readonly total: number;

package/src/self-dev/run-store.ts

@@ -16,8 +16,9 @@
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21 §5 (S3).
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dlopen, FFIType } from 'bun:ffi';
 import { randomUUID } from 'node:crypto';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { loadRunLedger, queryInterruptedRunLedgers, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { join, resolve, sep } from 'node:path';
@@ -68,6 +69,8 @@ export interface SelfDevRunState {
   createdAt: number;
   updatedAt: number;
   results: SelfDevJobResult[];
+  /** Redacted, bounded one-line projection for loop readers; legacy checkpoints omit it. */
+  summaryLine?: string;
   /** Undefined means a legacy checkpoint has no dependency information; each key is a shard ID and its array lists predecessor shard IDs. */
   dependencies?: Record<string, string[]>;
   /**
@@ -93,6 +96,10 @@ export interface SelfDevRunState {
    *  non-terminal goal 은 **실행중(running)** 이지 막힌(interrupted) 게 아니다. 죽었으면(오케스트레이터
    *  killed) 진짜 interrupted. isPidAlive 로 구분해 라이브 잡을 parked/repair-signals 에서 제외. */
   pid?: number;
+  /** OS process birth identity, paired with pid to reject a recycled pid. */
+  pidStart?: string;
+  /** Seat fixed at launch; survives removal of the launch worktree. */
+  seat?: 'OP' | 'TC' | 'MK' | 'UX';
 }
 
 /** `<ELANOUS_STATE_DIR or ~/.elanous>/self-dev-runs`. */
@@ -103,6 +110,34 @@ export function selfDevRunsDir(stateDir?: string): string {
 
 const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 
+/** Kernel process birth identity: Linux boot ID + start ticks or Darwin microseconds since epoch. */
+export function processBirthId(pid: number, platform: NodeJS.Platform = process.platform): string | undefined {
+  if (!Number.isSafeInteger(pid) || pid < 1) return undefined;
+  try {
+    if (platform === 'linux') {
+      const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+      const tail = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+      const ticks = tail[19]; // field 22 (starttime), after pid and parenthesized comm
+      const bootId = readFileSync('/proc/sys/kernel/random/boot_id', 'utf8').trim();
+      return ticks && /^\d+$/.test(ticks) && /^[0-9a-f-]{36}$/i.test(bootId)
+        ? `linux:${bootId}:${ticks}` : undefined;
+    }
+    if (platform === 'darwin') {
+      const libproc = dlopen('/usr/lib/libproc.dylib', {
+        proc_pidinfo: { args: [FFIType.i32, FFIType.i32, FFIType.u64, FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+      });
+      try {
+        const buf = new Uint8Array(136);
+        if (libproc.symbols.proc_pidinfo(pid, 3, 0n, buf, buf.length) !== buf.length) return undefined;
+        const view = new DataView(buf.buffer);
+        if (view.getUint32(12, true) !== pid) return undefined;
+        return `darwin:${view.getBigUint64(120, true) * 1_000_000n + view.getBigUint64(128, true)}`;
+      } finally { libproc.close(); }
+    }
+  } catch { /* Unreadable birth identity is not evidence of a match. */ }
+  return undefined;
+}
+
 function runPath(runId: string, dir: string): string {
   if (!RUN_ID.test(runId)) throw new Error(`invalid self-dev run ID: ${runId}`);
   const root = resolve(dir);
@@ -154,6 +189,40 @@ function mergeParticipants(
   return [...byId.values()];
 }
 
+const SUMMARY_LINE_LIMIT = 120;
+const FINISHED_RESULT_STATUSES = new Set(['done', 'failed', 'cancelled', 'superseded']);
+
+function boundedSummaryLine(text: string): string {
+  const redacted = redactSecretText(text.replace(/\s+/g, ' ').trim());
+  if (redacted.length <= SUMMARY_LINE_LIMIT) return redacted;
+  const head = redacted.slice(0, SUMMARY_LINE_LIMIT - 1).replace(/[\uD800-\uDBFF]$/, '');
+  return `${head}…`;
+}
+
+/** Read-only projection for loop readers; missing legacy fields are derived in memory. */
+export function runSummaryLine(state: SelfDevRunState): string {
+  if (state.summaryLine !== undefined) return boundedSummaryLine(state.summaryLine);
+  const feature = state.goals?.[0]?.feature ?? state.results[0]?.feature ?? '';
+  const head = feature.split(/\r?\n/, 1)[0]?.trim() ?? '';
+  const header = /^「하니스로 구현」\s+(\S+?)\s+—\s*(.*)$/.exec(head);
+  const id = state.goals?.[0]?.goalId ?? header?.[1] ?? state.goals?.[0]?.id ?? state.runId;
+  const phrase = (header?.[2] ?? head).split(/[.!?。；;]/, 1)[0]?.trim() ?? '';
+  const finished = state.results.length > 0
+    && state.results.every((result) => FINISHED_RESULT_STATUSES.has(result.status));
+  if (finished) {
+    // A completed shard cannot hide a failed one merely by settling later.
+    const result = state.results.find(({ status }) => status === 'failed')
+      ?? state.results.find(({ status }) => status === 'cancelled')
+      ?? state.results.find(({ status }) => status === 'superseded')
+      ?? state.results.at(-1)!;
+    const stage = result.stage ?? result.status;
+    const prNumber = result.prNumber ?? Number(/\/pull\/(\d+)(?:[/?#]|$)/.exec(result.prUrl ?? '')?.[1]);
+    const pr = Number.isSafeInteger(prNumber) && prNumber > 0 ? ` · PR #${prNumber}` : '';
+    return boundedSummaryLine(`${id} · ${stage}${pr}`);
+  }
+  return boundedSummaryLine(`「하니스로 구현」 ${id}${phrase ? ` — ${phrase}` : ''}`);
+}
+
 /** Persist a run checkpoint (fail-soft — never throws into the caller). */
 export function saveSelfDevRun(state: SelfDevRunState, dir = selfDevRunsDir()): void {
   try {
@@ -163,7 +232,10 @@ export function saveSelfDevRun(state: SelfDevRunState, dir = selfDevRunsDir()):
       const participants = mergeParticipants(current?.participants, state.participants);
       const saved = {
         ...state,
+        summaryLine: runSummaryLine({ ...state, goals: state.goals ?? current?.goals, summaryLine: undefined }),
         ...(participants === undefined ? {} : { participants }),
+        ...(current?.seat && !state.seat ? { seat: current.seat } : {}),
+        ...(current?.pidStart && current.pid === state.pid && !state.pidStart ? { pidStart: current.pidStart } : {}),
         ...(current?.parkedResolution && !state.parkedResolution ? { parkedResolution: current.parkedResolution } : {}),
       };
       writeSelfDevRun(saved, dir);