elanous 0.2.24 → 0.2.27

package/src/seat-loop/duty-ledger.ts

@@ -0,0 +1,64 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export const DUTY_STATUSES = ['standing', 'done', 'missed'] as const;
+export type DutyStatus = (typeof DUTY_STATUSES)[number];
+
+export type DutyRow = {
+  at: string;
+  seat: string;
+  duty: string;
+  source: string;
+  status: DutyStatus;
+  ref?: string;
+};
+
+export type DutyInput = Omit<DutyRow, 'at' | 'status'> & { at?: string; status?: DutyStatus };
+
+const DUTY_KEYS: ReadonlySet<string> = new Set(['at', 'seat', 'duty', 'source', 'status', 'ref']);
+const SEAT_PATTERN = /^(?:MK|UX|TC|OP|role:\S+)$/;
+
+const dutyLedgerPath = (root: string): string => join(root, 'seat-duties', 'duties.jsonl');
+
+function nonEmpty(row: Record<string, unknown>, key: string): string {
+  const value = row[key];
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`duty ${key} must be a non-empty string`);
+  return value;
+}
+
+function validate(input: Record<string, unknown>, now: () => Date): DutyRow {
+  for (const key of Object.keys(input)) {
+    if (!DUTY_KEYS.has(key)) throw new Error(`unknown duty key: ${key}`);
+  }
+  const seat = nonEmpty(input, 'seat');
+  if (!SEAT_PATTERN.test(seat)) throw new Error(`invalid duty seat: ${seat} (use MK|UX|TC|OP|role:<name>)`);
+  const status = input.status === undefined ? 'standing' : input.status;
+  if (!DUTY_STATUSES.includes(status as DutyStatus)) throw new Error(`invalid duty status: ${String(status)}`);
+  const at = input.at === undefined ? now().toISOString() : nonEmpty(input, 'at');
+  if (Number.isNaN(Date.parse(at))) throw new Error(`invalid duty at: ${at}`);
+  const row: DutyRow = { at, seat, duty: nonEmpty(input, 'duty'), source: nonEmpty(input, 'source'), status: status as DutyStatus };
+  if (input.ref !== undefined) row.ref = nonEmpty(input, 'ref');
+  return row;
+}
+
+/** Appends one validated row; a rejected row never reaches the file. */
+export function appendDuty(root: string, input: DutyInput, now: () => Date = () => new Date()): DutyRow {
+  const row = validate(input as Record<string, unknown>, now);
+  const path = dutyLedgerPath(root);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(row)}\n`);
+  try { debug.log('seat-loop.duty', 'appended', { seat: row.seat, duty: row.duty }); } catch { /* observation cannot change a write */ }
+  return row;
+}
+
+export function listDuties(root: string, filters: { seat?: string } = {}): DutyRow[] {
+  const path = dutyLedgerPath(root);
+  if (!existsSync(path)) return [];
+  const rows = readFileSync(path, 'utf8').split('\n').filter((line) => line.trim())
+    .map((line) => JSON.parse(line) as DutyRow)
+    .filter((row) => filters.seat === undefined || row.seat === filters.seat);
+  return rows.map((row, index) => ({ row, index }))
+    .sort((a, b) => Date.parse(a.row.at) - Date.parse(b.row.at) || a.index - b.index)
+    .map(({ row }) => row);
+}

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

@@ -85,7 +85,7 @@ export type SeatDeps = {
   /** Release schedules (version · cutAt) — a version is open while its cut is still ahead. Default reads the release ledger; unreadable ⇒ no checklist candidates (fail closed). */
   schedules?: () => Array<{ version: string; cutAt: string; landBy?: string | null }>;
   /** Checklist items of one version — default reads the release ledger DB (checklist.json is only a legacy import source since REL5b). */
-  checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string }>;
+  checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string; dispatchKind?: string }>;
   /** Optional injected traffic/handoff snapshots; defaults read the OP files. */
   trafficSignal?: TrafficSignalRead;
   handedCells?: ReadonlySet<string>;
@@ -588,6 +588,10 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
     }
     for (const item of items) {
       if (item.owner === seat && (item.status === 'yellow' || item.status === 'red')) {
+        if (item.dispatchKind && item.dispatchKind !== 'code') {
+          debug.log('seat.loop', 'skip-non-code-cell', { id: item.id, version, dispatchKind: item.dispatchKind });
+          continue;
+        }
         if (signal?.hold?.includes(item.id)) {
           debug.log('seat.loop', 'skip-signal-cell', { id: item.id, why: 'hold' });
           continue;

package/src/self-dev/decompose.ts

@@ -14,8 +14,12 @@
  *
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21 §6 (S2).
  */
-import { tierModel } from '../llm/model-defaults.js';
 import { debug } from '../debug/log.js';
+import {
+  resolveRoleModel,
+  type ModelResolutionSource,
+  type UserConfig,
+} from '../user-config.js';
 import {
   gradePhaseCompletability,
   type CompletabilitySizeSignals,
@@ -598,9 +602,39 @@ export async function decomposeSelfDevGoal(
   return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
+/** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */
+export type DecomposeModelSource = 'explicit' | ModelResolutionSource;
+
+export interface DecomposeModelResolution {
+  model: string;
+  source: DecomposeModelSource;
+}
+
+export interface DecomposeModelDeps {
+  /** Config handed to the planning-role default; omitted uses the user config. */
+  config?: UserConfig;
+}
+
+/**
+ * ROLE-RELAY-SPLIT — the decompose model selector (pure).
+ *
+ * An explicit `model` argument wins; the default is the existing planning-role
+ * resolver `resolveRoleModel('planning')` (env `ELANOUS_SKILL_PLAN_MODEL` ·
+ * `roleLlm.planning` · tier `best` — the same tier the old default used), NOT
+ * the review env `ELANOUS_PR_REVIEW_MODEL`: changing the review model must
+ * not drag the decompose model along.
+ */
+export function decomposeModel(explicit?: string, deps: DecomposeModelDeps = {}): DecomposeModelResolution {
+  const pinned = explicit?.trim();
+  if (pinned) return { model: pinned, source: 'explicit' };
+  const resolved = resolveRoleModel('planning', deps.config);
+  return { model: resolved.model, source: resolved.source };
+}
+
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */
 async function defaultDecomposeLlm(model?: string): Promise<SelfDevDecomposeLlm> {
   const { streamLLM } = await import('../llm.js');
-  const m = model || process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('best');
-  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: m, reasoningEffort: 'low' });
+  const { model: resolved, source } = decomposeModel(model);
+  debug.log('self-dev.decompose', 'model', { model: resolved, source });
+  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: resolved, reasoningEffort: 'low' });
 }

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

@@ -26,6 +26,7 @@ import { createRepositoryReferencedFileReader, type ReferencedFileReader } from
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
 import { debug } from '../debug/log.js';
+import { REVIEW_DEFERRED_TO_HOST_ENV, reviewDeferredToHostFromEnv } from '../self-implement/review-deferred-to-host.js';
 import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import type { GitRunResult } from '../git-fs/retry.js';
@@ -41,7 +42,7 @@ import type { IngestionEntry } from '../agent-substrate/execution/ingestion-poli
 import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-store.js';
-import { getUserConfig, resolveRoleLlm } from '../user-config.js';
+import { getUserConfig, resolveRoleLlm, type RoleLlmSource } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
 import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
@@ -1051,16 +1052,29 @@ export function unmannedToolReviewerRateFromConfig(
   return DEFAULT_UNMANNED_TOOL_REVIEWER_RATE;
 }
 
-function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection): void {
+function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection, skipped?: { reason: 'role-pinned'; roleSource: RoleLlmSource }): void {
   try {
     debug.log('self-dev.reviewer', 'tool-reviewer.select', {
       picked: selection.picked,
       rate: selection.rate,
       sample: selection.sample,
+      ...(skipped ? { skipped: skipped.reason, roleSource: skipped.roleSource } : {}),
     });
   } catch { /* fail-soft */ }
 }
 
+/**
+ * TOOL-REVIEWER-ROLE-PIN — a review role pinned for THIS launch (`--role-llm review=…` flag, or the Pod's
+ * `ELANOUS_ROLE_LLM_REVIEW` env pin) is a declaration that every review in the run uses that model; the
+ * unmanned tool-reviewer lottery must not swap it out (10-10 OR probe #25906: the draw picked the ACP
+ * reviewer and skipped the glm-5.3 pin, so bench arms got different reviewers). `environment` also covers the
+ * older `ELANOUS_PR_REVIEW_MODEL` env model pin. Config `roleLlm.review` is a standing default, not a per-launch
+ * pin — it keeps the lottery.
+ */
+export function reviewRolePinnedForLaunch(source: RoleLlmSource): boolean {
+  return source === 'flag' || source === 'environment';
+}
+
 async function defaultMakeUnmannedToolReviewLLM(): Promise<UnmannedToolReviewLLM> {
   const { makeLazyAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');
   return makeLazyAcpReviewLLM({ cwd: process.cwd() });
@@ -1085,6 +1099,8 @@ export async function buildDefaultSelfImplementSeams(
     makeToolReviewLLM?: () => UnmannedToolReviewLLM | Promise<UnmannedToolReviewLLM>;
     subscriptionReviewerDeps?: SubscriptionReviewerDeps;
     makeSubscriptionReviewLLM?: (spawn: ReturnType<typeof import('./review-provider-fallback.js').subscriptionReviewerSpawn>) => (prompt: string) => Promise<string>;
+    /** REVIEW-ACP-POD ②-b 시험 주입 — 기본은 env `ELANOUS_REVIEW_DEFERRED_TO_HOST=1`(발사 호스트가 싣는다). */
+    reviewDeferredToHost?: boolean;
   } = {},
 ): Promise<SelfImplementSeams> {
   const { defaultSeams } = await import('../self-implement/seams.js');
@@ -1139,11 +1155,14 @@ export async function buildDefaultSelfImplementSeams(
   let reviewerCanSelfRead: boolean | undefined;
   if (reviewerIsDefaultApiCall) {
     const rate = parseUnmannedToolReviewerRate(deps.toolReviewerRate) ?? unmannedToolReviewerRateFromConfig();
-    const sample = typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
-      ? deps.toolReviewerSample
-      : (deps.toolReviewerRoll ?? Math.random)();
-    const selection = selectUnmannedToolReviewer(rate, sample);
-    observeUnmannedToolReviewerSelection(selection);
+    const rolePinned = reviewRolePinnedForLaunch(reviewRole.source);
+    const sample = rolePinned
+      ? 1
+      : typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
+        ? deps.toolReviewerSample
+        : (deps.toolReviewerRoll ?? Math.random)();
+    const selection = rolePinned ? { picked: false, rate, sample } : selectUnmannedToolReviewer(rate, sample);
+    observeUnmannedToolReviewerSelection(selection, rolePinned ? { reason: 'role-pinned', roleSource: reviewRole.source } : undefined);
     if (selection.picked) {
       llmReview = await (deps.makeToolReviewLLM ?? defaultMakeUnmannedToolReviewLLM)();
       reviewerCanSelfRead = true;
@@ -1164,6 +1183,11 @@ export async function buildDefaultSelfImplementSeams(
       reviewerCanSelfRead = undefined;
     }
   }
+  // REVIEW-ACP-POD ②-b — 발사 호스트가 Claude ACP 로 리뷰할 때만 실린다. 리뷰 심이 api 리뷰어를 부르지 않는다(판정은 호스트).
+  const reviewDeferredToHost = deps.reviewDeferredToHost ?? reviewDeferredToHostFromEnv(process.env);
+  if (reviewDeferredToHost) {
+    try { debug.log('self-dev.review-fallback', 'review-deferred-to-host', { env: REVIEW_DEFERRED_TO_HOST_ENV, source: deps.reviewDeferredToHost !== undefined ? 'option' : 'env' }); } catch { /* fail-soft */ }
+  }
   const opensPr = plan.completion !== 'worktree-only';
   const target = plan.target === undefined ? undefined : revalidateHarnessTarget(plan.target);
   if (target?.status === 'outside-home') {
@@ -1181,6 +1205,7 @@ export async function buildDefaultSelfImplementSeams(
     ...(plan.self?.activityGraceSec !== undefined ? { implementActivityGraceSec: plan.self.activityGraceSec } : {}),
     llmReview,
     ...(subscriptionReviewLLM ? { subscriptionReviewLLM } : {}),
+    ...(reviewDeferredToHost ? { reviewDeferredToHost: true } : {}),
     ...(reviewerCanSelfRead !== undefined ? { reviewerCanSelfRead } : {}),
     ...(deps.reviewScopeDiff ? { reviewScopeDiff: deps.reviewScopeDiff } : {}),
     onProgress: ({ stage, message }) => {

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

@@ -7,16 +7,19 @@ import { debug } from '../debug/log.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { appendRunLedgerEntry, listRunLedgers, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { clipRegateDetail, regateFailureFacts, type HostRegateFailure } from '../self-implement/regate-detail.js';
 import { DRAFT_SWEEP_CLOSE_CAP } from './draft-sweep.js';
 import { PROTECTED_LABELS, sameVerifiedGoal, type DraftTriagePr } from './draft-triage-rules.js';
 
-export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved';
+export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved' | 'timed-out-harvestable';
 export interface PrTerminalRecord {
   childRunId: string;
   prNumber: number | null;
   prUrl: string | null;
   repository: string | null;
   headSha: string | null;
+  /** Copied from disposition.branch when present; null when the child did not name a branch. */
+  branch?: string | null;
   terminalClass: PodTerminalClass;
   stage: string | null;
   owner: string;
@@ -24,13 +27,16 @@ export interface PrTerminalRecord {
   card: string | null;
   at: string;
   /** Which host-regate gate failed and why — null for every other terminal. */
-  hostRegateFailure: { step: string; detail: string; os: string } | null;
+  /** HOST-REGATE-REASON-LOST: detail keeps a bounded head ⊕ tail (4KB); pr-head · merge steps add the expected/actual
+   *  head, merge-conflict adds the conflicted files, merge adds the failure kind (race · moved head · conflict · policy). */
+  hostRegateFailure: (HostRegateFailure & { os: string }) | null;
 }
 export interface PodTerminalInput {
   childRunId: string;
   state: 'complete' | 'failed' | 'aborted';
   disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean;
-    hostRegate?: { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string } | null } | null;
+    branch?: string | null;
+    hostRegate?: { passed: boolean; failures: HostRegateFailure[]; os: string } | null } | null;
   env?: Readonly<Record<string, string | undefined>>;
   prBody?: string;
   goalText?: string;
@@ -47,6 +53,7 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const prUrl = typeof d?.prUrl === 'string' ? d.prUrl : null;
   const match = prUrl && /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\/?$/.exec(prUrl);
   const repository = match && Number(match[3]) === prNumber ? `${match[1]}/${match[2]}` : null;
+  const branch = typeof d?.branch === 'string' && d.branch.trim() ? d.branch.trim() : null;
   const card = cardOf(input.prBody) ?? cardOf(input.goalText);
   const seat = input.env?.ELANOUS_HARNESS_SEAT;
   const ownerSource = seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? 'seat' : card ? 'card' : 'unknown';
@@ -55,14 +62,16 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const hostRegateFailure = d?.stage === 'host-regate-failed' && hostRegate?.passed === false
     ? { step: typeof firstFailure?.step === 'string' && firstFailure.step ? firstFailure.step : 'unknown',
       detail: typeof firstFailure?.detail === 'string' && firstFailure.detail
-        ? firstFailure.detail.split(/\s+/).filter(Boolean).join(' ').slice(0, 300)
+        ? clipRegateDetail(firstFailure.detail.split(/\s+/).filter(Boolean).join(' '))
         : 'failures empty',
+      ...regateFailureFacts(firstFailure),
       os: hostRegate.os }
     : null;
   return {
-    childRunId: input.childRunId, prNumber, prUrl, repository,
+    childRunId: input.childRunId, prNumber, prUrl, repository, branch,
     headSha: typeof d?.checkedHeadCommit === 'string' && /^[a-f0-9]{40}$/i.test(d.checkedHeadCommit) ? d.checkedHeadCommit : null,
     terminalClass: !d ? 'failed-pr-unobserved' : d.merged === true ? 'landed'
+      : prNumber === null && d.stage === 'timed-out' && branch ? 'timed-out-harvestable'
       : prNumber === null ? 'failed-no-pr'
         : input.state === 'complete' && d.ok !== false ? 'merge-ready-not-merged' : 'failed-with-pr',
     stage: d?.stage ?? null, hostRegateFailure,
@@ -282,7 +291,7 @@ export async function replayPodTerminals(options: DraftResidueReplayOptions = {}
     for (const terminal of terminals) {
       const record = terminal.data as unknown as PrTerminalRecord;
       if (typeof record.childRunId !== 'string' || typeof record.owner !== 'string'
-        || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved'].includes(record.terminalClass)
+          || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved', 'timed-out-harvestable'].includes(record.terminalClass)
         || (record.prNumber !== null && (!Number.isSafeInteger(record.prNumber) || record.prNumber <= 0))
         || (record.repository !== null && (typeof record.repository !== 'string' || !/^[\w.-]+\/[\w.-]+$/.test(record.repository)))) {
         throw new Error(`Invalid terminal record: ${ledgerRunId}`);
@@ -338,6 +347,7 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
       adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal', data: { ...record } }, ctx.ledgerDir);
       log('terminal-recorded');
     }
+    // AUT-TIMEOUT-NO-HARVEST 첫 조각은 «분류만» — 그 branch 로 PR 을 여는 효과는 다음 조각(원격 가지 존재·기존 PR 확인 관문과 함께).
     if (record.terminalClass === 'failed-no-pr' || record.terminalClass === 'failed-pr-unobserved' || record.prNumber === null) {
       acknowledge('complete', 0);
       return skipped(record.terminalClass);

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

@@ -33,7 +33,7 @@ export interface DraftSweepAdapters {
   /** Undefined means liveness could not be established. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void>;
-  closeDraft(repository: string, number: number, comment: string): Promise<void>;
+  closeDraft(repository: string, number: number): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
   /** Current owner, accounting for a later claim release; only draft metrics need this distinction. */
@@ -121,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;
@@ -462,6 +478,23 @@ const label = (action: 'mark-stalled' | 'close', name?: string): string => {
 const runningLabel = label('mark-stalled');
 const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
+
+/** Keep repository labels bounded; the complete reason and PR number live in the closed event. */
+export function sweptReasonLabel(reason: string): string {
+  const kinds = ['superseded-by', 'duplicate-of-open', 'claim-expired', 'stale-unobserved',
+    'harvest-expired', 'stale-ended-run'] as const;
+  const kind = kinds.find((name) => reason === name || reason.startsWith(`${name} `)) ?? 'other';
+  return `elanous:swept:${kind}`;
+}
+
+async function closeSweptDraft(adapters: Pick<DraftSweepAdapters, 'setLabels' | 'closeDraft'>,
+  repository: string, number: number, reason: string, onLabelApplied?: () => void): Promise<void> {
+  await adapters.setLabels(repository, number, { add: sweptReasonLabel(reason), remove: [] });
+  onLabelApplied?.();
+  await adapters.closeDraft(repository, number);
+  try { debug.log('self-dev.draft-sweep', 'closed', { pr: number, reason }); } catch { /* fail-soft */ }
+}
+
 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;
@@ -556,8 +589,7 @@ export async function supersedeDraftsOnMerge(input: {
       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.`);
+        await closeSweptDraft(adapters, repository, draft.number, decision.reason);
         closed.push(draft.number);
       } catch (failure) {
         kept.push(draft.number);
@@ -769,6 +801,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;
@@ -882,7 +921,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
     // A newer open draft of the same goal lineage (a rerun, e.g. a forced requeue) supersedes this one even when
     // its running claim is fresh or its run is still live. Holds, merged twins and the title-based duplicate rule keep their priority.
-    const lineageNewer = contradiction || draft.labels.includes(harvestableLabel) ? undefined : newerLineageDraft(draft, drafts);
+    // 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 });
@@ -895,9 +937,24 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         // Every lineage outcome that does not close falls through to the existing rules (preservation contract):
         // a duplicate this rule cannot settle is decided exactly as it was before this rule existed.
         const fallThrough = (why: string) => {
-          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why }); } catch { /* fail-soft */ }
+          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 */ }
         };
-        if (runLive && !adapters.supersedeRun) fallThrough('lineage-duplicate-run-live');
+        // 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');
@@ -921,6 +978,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
           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;
@@ -932,12 +991,15 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
                 });
                 labelsChanged = true;
               }
-              await adapters.closeDraft(repository, draft.number,
-                `Draft sweep: ${reason} (https://github.com/${repository}/pull/${lineageNewer.number}). Branch preserved.`);
+              await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
               entry.applied = true;
             } catch (error) {
               if (labelsChanged) entry.partialApplied = true;
-              else closes -= 1;
+              else {
+                closes -= 1;
+                lineageCounts.closed -= 1;
+                if (harvestable) lineageCounts.harvestableClosed -= 1;
+              }
               entry.error = String(error);
             }
             continue;
@@ -988,11 +1050,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       if (!apply || action !== 'close') continue;
       let labelsChanged = false;
       try {
-        const owner = await adapters.getClaimOwner?.(repository, draft.number) ?? '미상';
+        await adapters.getClaimOwner?.(repository, draft.number);
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
-        await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+        await closeSweptDraft(adapters, repository, draft.number, entry.reason, () => { labelsChanged = true; });
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -1038,12 +1099,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         labelsChanged = true;
       }
       if (action === 'close') {
-        await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
-          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
-          : decision.reason === 'harvest-expired'
-          ? `Draft sweep: harvest-expired — 종단이 수확 대상으로 표시한 뒤 ${STALLED_DRAFT_HOURS}h 동안 수확 없음. Branch preserved; reopen to restore.`
-          : `Draft sweep: ${decision.reason}${decision.reason.startsWith('superseded-by #')
-            ? ` (https://github.com/${repository}/pull/${decision.reason.slice('superseded-by #'.length).match(/^\d+/)![0]})` : ''}. Branch preserved.`);
+        await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
       }
       entry.applied = labelsChanged || action === 'close';
     } catch (error) {
@@ -1052,6 +1108,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/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 { psProcessStartMs } from '../harness/harness-stop.js';
 import { adoptRunCard } from '../task-agent/run-adopt.js';
 import { availableParallelism, cpus } from 'node:os';
 import { selfDevRunsDir } from './run-store.js';
@@ -912,12 +913,15 @@ async function deleteLabelledJobs(runId: string, selectedTargets: readonly { con
  *  take minutes before that, and a stop in that window found «no process» (10-01 · three runs). */
 export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDir(), registryDir: string | null = launchRegistryDir()): string {
   const pidPath = join(runsDir, runId, 'pid.json');
+  // The observer reads `ps -o lstart=`, whose precision is one second. Record that same
+  // process birth value when available so a launch near a second boundary still matches.
+  const startedAt = psProcessStartMs(process.pid) ?? Date.now() - Math.floor(process.uptime() * 1000);
   mkdirSync(join(runsDir, runId), { recursive: true });
   const temporary = `${pidPath}.${process.pid}.${randomUUID()}.tmp`;
   const fd = openSync(temporary, 'wx', 0o600);
   try {
     try {
-      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0 }));
+      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt, argv0: process.argv0 }));
     } finally { closeSync(fd); }
     renameSync(temporary, pidPath);
   } catch (error) { unlinkSync(temporary); throw error; }
@@ -925,7 +929,7 @@ export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDi
   if (registryDir !== null) {
     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,
+    writeLaunchBinding(runId, { pid: process.pid, startedAt, argv0: process.argv0,
       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);