elanous 0.2.11 → 0.2.13

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

@@ -27,6 +27,10 @@ export interface DraftSweepAdapters {
   closeDraft(repository: string, number: number, comment: string): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
+  /** Whether the current owned run has a self-implement.result final observation, even if its worktree remains. */
+  hasFinalRunResult?(draft: SweepDraft, repository: string): Promise<boolean | undefined>;
+  /** Per-file last change on the draft branch; undefined means file coverage is unverified. */
+  getLatestFileChanges?(draft: SweepDraft, repository: string): Promise<Readonly<Record<string, string>> | undefined>;
 }
 
 export interface DraftSweepOptions {
@@ -120,9 +124,23 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     return finish();
   }
   let statuses: Map<number, string | undefined>;
+  let finality: Map<number, boolean | undefined>;
+  let latestFileChanges: Map<number, Readonly<Record<string, string>> | undefined>;
   try {
     statuses = new Map<number, string | undefined>();
-    for (const draft of drafts) statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
+    finality = new Map<number, boolean | undefined>();
+    latestFileChanges = new Map<number, Readonly<Record<string, string>> | undefined>();
+    for (const draft of drafts) {
+      const status = await adapters.getRunStatus(draft, repository);
+      // A prior final cannot terminate a new active run on the same draft.
+      const active = status === 'running' || status === 'probable-running';
+      const final = active ? false : await adapters.hasFinalRunResult?.(draft, repository);
+      finality.set(draft.number, final);
+      statuses.set(draft.number, final ? 'self-implement.result final' : status);
+      if (draft.changedFiles?.length && adapters.getLatestFileChanges) {
+        latestFileChanges.set(draft.number, await adapters.getLatestFileChanges(draft, repository));
+      }
+    }
   } catch (error) {
     result.error = String(error);
     return finish();
@@ -132,8 +150,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
-  for (const draft of drafts) {
+  for (const listedDraft of drafts) {
+    const draft = { ...listedDraft, latestFileChanges: latestFileChanges.get(listedDraft.number) };
     const runStatus = statuses.get(draft.number);
+    const finalRunResult = finality.get(draft.number);
     const states = stateLabels.filter((state) => draft.labels.includes(state.name));
     const contradiction = states.length > 1 || draft.labels.includes(approvalLabel ?? '');
     if (draft.labels.includes(releaseHoldLabel ?? '') || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
@@ -147,8 +167,14 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
     // 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, liveBranches, ageHours: idleHours }) : undefined;
-    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true;
+    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      finalRunResult, ageHours: idleHours }) : undefined;
+    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true
+      || mergedDecision?.reason.startsWith('duplicate-of-open #') === true;
+    if (!contradiction && mergedDecision?.reason === 'branch-finality-unobserved') {
+      record({ number: draft.number, action: 'keep', reason: mergedDecision.reason, applied: false });
+      continue;
+    }
     // Without an observed update time, neither expiration nor a fallback to creation time can authorize mutation —
     // but a merged twin does not need the update time, so superseded keeps its priority over the unobserved claim.
     if (isClaimed && !supersededClaim && (typeof draft.updatedAt !== 'string' || !Number.isFinite(Date.parse(draft.updatedAt)))) {
@@ -162,13 +188,21 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours >= CLAIM_IDLE_HOURS) {
       claimExpired += 1;
-      if (runStatus === 'running' || runStatus === 'probable-running' || liveBranches.has(draft.branch)) {
+      if (liveBranches.has(draft.branch) && finalRunResult === undefined
+        && runStatus !== 'running' && runStatus !== 'probable-running') {
+        record({ number: draft.number, action: 'keep', reason: 'branch-finality-unobserved', applied: false });
+        continue;
+      }
+      if (runStatus === 'running' || runStatus === 'probable-running' ||
+        (runStatus !== 'self-implement.result final' && liveBranches.has(draft.branch))) {
         record({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
         continue;
       }
       const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
       if (action === 'close') closes += 1;
-      const entry: DraftSweepEntry = { number: draft.number, action, reason: action === 'close' ? 'claim-expired' : 'close-cap',
+      const entry: DraftSweepEntry = { number: draft.number, action,
+        reason: action === 'close' ? runStatus === 'self-implement.result final'
+          ? 'claim-expired (self-implement.result final; worktree is not live)' : 'claim-expired' : 'close-cap',
         ...(action === 'close' ? { statusLabel: stalledLabel } : {}), applied: false };
       record(entry);
       if (!apply || action !== 'close') continue;
@@ -178,7 +212,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
         await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — 런·워크트리 없음 · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -191,8 +225,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
       continue;
     }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches,
-      ageHours: runStatus ? ageHours : idleHours });
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
       if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
@@ -204,7 +238,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       : decision.reason;
     const isLive = decision.reason === 'live';
     const target = action === 'report' ? undefined : action === 'close'
-      ? decision.reason.startsWith('superseded-by #') ? supersededLabel : stalledLabel
+      ? decision.reason.startsWith('superseded-by #') || decision.reason.startsWith('duplicate-of-open #') ? supersededLabel : stalledLabel
       : isLive ? (states.length ? runningLabel : undefined) : runStatus && (states[0]?.name === runningLabel || states.length === 0) ? stalledLabel : undefined;
     const entry: DraftSweepEntry = { number: draft.number, action, reason, ...(target ? { statusLabel: target } : {}), applied: false };
     record(entry);

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

@@ -6,14 +6,25 @@ export interface DraftTriagePr {
   title?: string;
   branch: string;
   labels?: readonly string[];
+  body?: string;
+  mergeCommitMessage?: string;
+  landingVerifiedComments?: readonly string[];
+  createdAt?: string;
+  mergedAt?: string;
+  changedFiles?: readonly string[];
+  /** Latest change to each draft file, from the draft branch's commit history. Missing is not creation time. */
+  latestFileChanges?: Readonly<Record<string, string>>;
 }
 
 export interface DraftTriageInput {
   draft: DraftTriagePr;
   runStatus: string | undefined;
   mergedTwins: readonly DraftTriagePr[];
+  openDrafts?: readonly DraftTriagePr[];
   ageHours: number;
   liveBranches: ReadonlySet<string>;
+  /** false only when the current run's final result has actually been checked and ruled out. */
+  finalRunResult?: boolean;
 }
 
 export type DraftDecision = { action: 'close' | 'keep'; reason: string };
@@ -25,11 +36,22 @@ const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
   .map((label) => label.name), RELEASE_PATH_LABEL]);
 
 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 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 =>
+  new RegExp(`\\blanding-verified\\s*:\\s*(?:draft|superseded|수확)\\s*#${number}(?!\\d)\\b`, 'i').test(text);
 
-export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranches }: DraftTriageInput): DraftDecision {
+export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
-  if (runStatus === 'running' || runStatus === 'probable-running' || (draft.branch && liveBranches.has(draft.branch))) {
+  if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)
+    && finalRunResult === undefined && runStatus !== 'running' && runStatus !== 'probable-running') {
+    return { action: 'keep', reason: 'branch-finality-unobserved' };
+  }
+  if (runStatus === 'running' || runStatus === 'probable-running' ||
+    (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch))) {
     return { action: 'keep', reason: 'live' };
   }
   const lineage = goalId(draft.branch);
@@ -37,9 +59,39 @@ export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranc
     (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
   ));
   if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  const stem = branchStem(draft.branch);
+  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
+      && 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 && (
+    [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)));
+  if (files?.length && files.every((file) => {
+    const changed = Date.parse(draft.latestFileChanges?.[file] ?? '');
+    return Number.isFinite(changed) && changed >= created && later.some((pr) =>
+      pr.changedFiles?.includes(file) && Date.parse(pr.mergedAt!) > changed);
+  })) {
+    const covering = later.filter((pr) => pr.changedFiles?.some((file) => files.includes(file)
+      && Date.parse(pr.mergedAt!) > Date.parse(draft.latestFileChanges![file]!)));
+    return { action: 'close', reason: `superseded-by #${covering.map((pr) => pr.number).join(', #')} (all-files-landed)` };
+  }
   if (!runStatus) return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
     ? { action: 'close', reason: 'stale-unobserved' }
     : { action: 'keep', reason: 'unobserved' };
+  if (runStatus === 'self-implement.result final') return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
+    ? { action: 'close', reason: 'stale-ended-run (self-implement.result final; worktree is not live)' }
+    : { action: 'keep', reason: 'recent (self-implement.result final; worktree is not live)' };
   if (Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS) return { action: 'close', reason: 'stale-ended-run' };
   return { action: 'keep', reason: 'recent' };
 }

package/src/self-implement/budget-gate.ts

@@ -101,21 +101,27 @@ function codexCandidateUsable(candidate: BudgetCodexCandidate, cap: number | und
 function slotUsable(
   provider: string,
   input: DecideBudgetInput,
-): { usable: boolean; reason: string } {
+  allowUnmeasured = false,
+): { usable: boolean; reason: string; unmeasured?: boolean } {
   if (provider === CODEX_PROVIDER) {
     const cap = capFor(input.maxUsedPercent, CODEX_PROVIDER);
-    const usable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
-    return { usable, reason: formatCodexReason(input.codexCandidates, cap) };
+    const measuredUsable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
+    const unmeasured = allowUnmeasured && !measuredUsable && (input.codexCandidates.length === 0
+      || input.codexCandidates.some((candidate) => candidate.reached !== true
+        && (typeof candidate.usedPercent !== 'number' || !Number.isFinite(candidate.usedPercent))));
+    return { usable: measuredUsable || unmeasured, reason: formatCodexReason(input.codexCandidates, cap), ...(unmeasured ? { unmeasured: true } : {}) };
   }
   if (provider === GROK_PROVIDER) {
     const cap = capFor(input.maxUsedPercent, GROK_PROVIDER);
     const known = typeof input.grokUsedPercent === 'number' && Number.isFinite(input.grokUsedPercent);
-    const usable = cap === undefined
+    const unmeasured = allowUnmeasured && !known;
+    const usable = unmeasured || (cap === undefined
       ? known
-      : known && (input.grokUsedPercent as number) < cap;
+      : known && (input.grokUsedPercent as number) < cap);
     return {
       usable,
       reason: formatGrokReason(input.grokUsedPercent, cap),
+      ...(unmeasured ? { unmeasured: true } : {}),
     };
   }
   return { usable: false, reason: `${provider}: 예산 판정 없음` };
@@ -127,6 +133,15 @@ function slotUsable(
  * 아무것도 못 쓰면 onShortfall 이 wait-reset 일 때만 wait-reset, 아니면 stop.
  */
 export function decideBudget(input: DecideBudgetInput): BudgetDecision {
+  return decideBudgetWithPolicy(input, false).decision;
+}
+
+/** Only the harness launch gate treats an unmeasured provider as launchable. */
+export function decideLaunchBudget(input: DecideBudgetInput): { decision: BudgetDecision; unmeasuredProvider?: string } {
+  return decideBudgetWithPolicy(input, true);
+}
+
+function decideBudgetWithPolicy(input: DecideBudgetInput, allowUnmeasured: boolean): { decision: BudgetDecision; unmeasuredProvider?: string } {
   const reasons: string[] = [];
   if (input.preference.chain.length === 0) {
     reasons.push('chain: 비었음 — tools.selfImplement.childLlm.chain 도 llm.fallbackChain 도 없다');
@@ -134,7 +149,7 @@ export function decideBudget(input: DecideBudgetInput): BudgetDecision {
   let firstUnusable = false;
   for (let index = 0; index < input.preference.chain.length; index++) {
     const slot = input.preference.chain[index]!;
-    const judged = slotUsable(slot.provider, input);
+    const judged = slotUsable(slot.provider, input, allowUnmeasured);
     reasons.push(judged.reason);
     if (!judged.usable) {
       if (index === 0) firstUnusable = true;
@@ -142,16 +157,18 @@ export function decideBudget(input: DecideBudgetInput): BudgetDecision {
     }
     const action: BudgetAction = index === 0 || !firstUnusable ? 'proceed' : 'next-provider';
     return {
-      action,
-      provider: slot.provider,
-      ...(slot.model !== undefined ? { model: slot.model } : {}),
-      reasons,
+      decision: {
+        action,
+        provider: slot.provider,
+        ...(slot.model !== undefined ? { model: slot.model } : {}),
+        reasons,
+      },
+      ...(judged.unmeasured ? { unmeasuredProvider: slot.provider } : {}),
     };
   }
   const onShortfall = input.preference.budgetGate.onShortfall;
   return {
-    action: onShortfall === 'wait-reset' ? 'wait-reset' : 'stop',
-    reasons,
+    decision: { action: onShortfall === 'wait-reset' ? 'wait-reset' : 'stop', reasons },
   };
 }
 

package/src/self-implement/gate-candidate-ranking.ts

@@ -0,0 +1,60 @@
+import type { GateCallerReason } from './gate-scope.js';
+
+export interface GateCallerCandidate {
+  readonly file: string;
+  readonly reasons: readonly GateCallerReason[];
+}
+
+/** Path segments between `file` and the nearest changed path's directory (0 = same directory). */
+function directoryDistance(file: string, changedPaths: readonly string[]): number {
+  const dir = file.split('/').slice(0, -1);
+  let best = Infinity;
+  for (const changed of changedPaths) {
+    const other = changed.split('/').slice(0, -1);
+    let shared = 0;
+    while (shared < dir.length && shared < other.length && dir[shared] === other[shared]) shared += 1;
+    best = Math.min(best, dir.length - shared + other.length - shared);
+  }
+  return best;
+}
+
+/**
+ * Rank gate caller tests by closeness to the change, nearest first (GATE-CALLERS2 — the cap keeps the head).
+ * A `route` candidate names a route on a changed diff line, so it ranks with touched tests (distance 0);
+ * otherwise the distance is the shortest reverse-import path from a changed file (direct importer = 1,
+ * unreachable = after every reachable candidate). Equal distances prefer the test nearest a changed file
+ * in the directory tree, then numeric-aware path order. Inputs are not modified.
+ * `importersByFile` maps each imported file to its immediate importers (tests or sources).
+ */
+export function rankGateCallerCandidates<T extends GateCallerCandidate>(
+  changedPaths: readonly string[],
+  candidates: readonly T[],
+  importersByFile: ReadonlyMap<string, readonly string[]>,
+): T[] {
+  const distances = new Map<string, number>();
+  const queue: string[] = [];
+  for (const path of changedPaths) {
+    if (distances.has(path)) continue;
+    distances.set(path, 0);
+    queue.push(path);
+  }
+  for (let index = 0; index < queue.length; index += 1) {
+    const source = queue[index]!;
+    const nextDistance = distances.get(source)! + 1;
+    for (const importer of importersByFile.get(source) ?? []) {
+      if (distances.has(importer)) continue;
+      distances.set(importer, nextDistance);
+      queue.push(importer);
+    }
+  }
+  const keys = new Map(candidates.map((candidate) => [candidate, {
+    distance: candidate.reasons.includes('route') ? 0 : distances.get(candidate.file) ?? Infinity,
+    directory: directoryDistance(candidate.file, changedPaths),
+  }]));
+  return [...candidates].sort((left, right) => {
+    const a = keys.get(left)!;
+    const b = keys.get(right)!;
+    return (a.distance - b.distance || 0) || (a.directory - b.directory || 0)
+      || left.file.localeCompare(right.file, undefined, { numeric: true });
+  });
+}

package/src/self-implement/gate-scope.ts

@@ -30,6 +30,7 @@
 
 import { importerTestsNotInRunSet, type ImporterTestIndex } from './importer-test-index.js';
 import type { RouteConsumerTestIndex } from './route-consumer-test-index.js';
+import { rankGateCallerCandidates } from './gate-candidate-ranking.js';
 
 export const GATE_CALLER_TEST_LIMIT = 30;
 export type GateCallerReason = 'import' | 'route';
@@ -249,11 +250,7 @@ interface GateScopeDecision {
   readonly unverified: readonly string[];
   /** elanous 자체가 남긴 런타임 산출물. 미검증 사용자 변경에서 제외하되 경로를 보존한다. */
   readonly elanousRuntimeArtifacts: readonly string[];
-  /** ⭐ **편집되지 않았는데 함께 끌어와 돌린** 연관 테스트(`changed-tests` 분기 전용).
-   *  ⚠️ 직전 판본은 이 자리에 `unrunRelatedTests`(=실행집합에 없는 연관 테스트)를 뒀는데,
-   *  실행집합이 연관 테스트를 **전부 포함**하도록 바뀌었으므로 그 값은 **정의상 항상 빈 배열**이었다.
-   *  빈 배열을 보고 *"안 돈 게 없다"* 고 읽게 되지만 그건 사실 확인이 아니라 계산의 결과였다
-   *  (관측이 사실 아닌 값을 나르는 형태). ⇒ **실제로 일어난 일**을 센다: 합집합이 구제한 파일들. */
+  /** ⭐ 편집되지 않았는데 함께 끌어와 돌린 연관 테스트(`changed-tests` 분기) — 합집합이 실제로 구제한 파일들. */
   readonly pulledInRelatedTests: readonly string[];
   /** 실행 집합에 없는, 변경 소스를 상대 import 하는 테스트. 색인이 주입되지 않으면 null. */
   readonly importerTestsNotRun: {
@@ -352,8 +349,9 @@ export function resolveGateScope(
       }
     }
   }
-  const candidates = [...callers].sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
-    .map(([file, reasons]) => ({ file, reasons: [...reasons] }));
+  // GATE-CALLERS2 — the cap keeps the candidates closest to the change, not the alphabetically first.
+  const candidates = rankGateCallerCandidates(userChanged, [...callers].map(([file, reasons]) => ({ file, reasons: [...reasons] })),
+    importerTestIndex?.testsBySource ?? new Map());
   const callerTests = candidates.slice(0, GATE_CALLER_TEST_LIMIT);
   const callerTestsOverflow = candidates.slice(GATE_CALLER_TEST_LIMIT);
   const runWithCallers = (tests: readonly string[]) => [...new Set([...tests, ...callerTests.map(({ file }) => file)])];
@@ -364,11 +362,14 @@ export function resolveGateScope(
   });
 
   if (testFiles.length > 0) {
+    // Edited tests ⊕ every related test of the changed sources ⊕ capped callers (restored 10-04: #23467 narrowed this
+    // to edited tests only, so a co-located sibling of a changed source stopped running — 0.2.12 gate introduced).
     const allRelatedTests = conventional;
     const runSet = runWithCallers([...testFiles, ...allRelatedTests]);
     // 편집된 테스트만 돌렸다면 빠졌을 것들 — 이 목록이 비어있지 않다는 것은 합집합이 실제로 구제했다는 뜻이다.
     const pulledInRelatedTests = allRelatedTests.filter((f) => !testFiles.includes(f));
-    return { ...base, ...withDocumentNonContribution(runSet), testArgs: runSet, unverified: unverifiedFor(runSet), pulledInRelatedTests, importerTestsNotRun: observationFor(runSet), skipTestStep: false, reason: 'changed-tests' };
+    return { ...base, ...withDocumentNonContribution(runSet), testArgs: runSet, unverified: unverifiedFor(runSet), pulledInRelatedTests,
+      importerTestsNotRun: observationFor(runSet), skipTestStep: false, reason: 'changed-tests' };
   }
   if (userChanged.length === 0) {
     // postsync 빈 범위는 기존 no-changes(깨끗함)와 다른 값이다. 일반 호출자는 계속 no-changes를 읽는다.

package/src/self-implement/headless-elanous-driver.ts

@@ -1170,11 +1170,16 @@ export interface HeadlessGoalLoopPtyResult {
 
 export function pickImplementRoleForGoal(document: string): ReturnType<typeof resolveRoleLlm> | undefined {
   try {
-    const role = resolveRoleLlm('implement');
+    const config = getUserConfig();
+    const role = resolveRoleLlm('implement', { config });
+    if (config.harness?.difficultyPlacement !== true || role.source !== 'default') return role;
     const signals = goalDifficultySignals(document);
     const level = classifyGoalDifficulty(signals);
     const picked = resolveImplementDifficulty(role, level);
-    try { debug.log('llm.difficulty', 'pick', { level, tier: picked.tier ?? null, signals }); } catch { /* observation is fail-soft */ }
+    try {
+      debug.log('llm.difficulty', 'pick', { level, tier: picked.tier ?? null, signals });
+      debug.log('harness.role-llm', 'difficulty-placement', { difficulty: level, tier: picked.tier, source: role.source });
+    } catch { /* observation is fail-soft */ }
     return picked;
   } catch { return undefined; }
 }

package/src/self-implement/l8-merge-queue.ts

@@ -1,8 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { NEXT_MD_PATH, resolveNextMdConflict } from '../release-loop/next-md-merge.js';
+import { getDefaultLogStore } from '../mss/logging/log-store.js';
 
 type Command = (bin: string, args: readonly string[], cwd: string) => { status: number | null; stdout: string; stderr: string };
 export type L8MergeQueueInput = { number: number; cwd: string; matchHeadCommit: string };
@@ -13,6 +14,161 @@ export type L8MergeQueueDeps = {
   acquire?: (cwd: string) => Promise<() => void>;
 };
 
+export type L8ShadowVerdict = { number: number; head: string; base?: string; verdict: 'pass' | 'conflict' | 'fail'; detail?: string; tests: string[]; at: string };
+export type L8ShadowQueueState = { pending: { number: number; head: string }[]; verdicts: L8ShadowVerdict[] };
+export type L8ShadowQueueDeps = L8MergeQueueDeps & { observe?: (verdict: L8ShadowVerdict) => void | Promise<void> };
+
+function shadowCommand(execute: Command, bin: string, args: string[], cwd: string): string {
+  const result = execute(bin, args, cwd);
+  if (result.status !== 0) throw new Error(`${bin} ${args.join(' ')}: ${(result.stderr || result.stdout || `exit ${result.status}`).trim().slice(0, 500)}`);
+  return args.includes('-z') ? result.stdout : result.stdout.trim();
+}
+
+function shadowQueuePath(cwd: string, execute: Command): string {
+  const dir = shadowCommand(execute, 'git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd);
+  if (!dir) throw new Error('merge queue common git directory unavailable');
+  return join(dir, 'elanous-l8-shadow-queue.json');
+}
+
+function readShadowQueue(path: string): L8ShadowQueueState {
+  if (!existsSync(path)) return { pending: [], verdicts: [] };
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!value || typeof value !== 'object' || !('pending' in value) || !Array.isArray(value.pending)
+    || !value.pending.every((p: { number?: number; head?: string }) => Number.isSafeInteger(p?.number) && p.number! > 0 && typeof p.head === 'string' && /^[0-9a-f]{40}$/i.test(p.head))
+    || !('verdicts' in value) || !Array.isArray(value.verdicts)) throw new Error('invalid shadow queue ledger');
+  return value as L8ShadowQueueState;
+}
+
+function writeShadowQueue(path: string, state: L8ShadowQueueState): void {
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(state, null, 2) + '\n', { flag: 'wx' });
+    renameSync(temp, path);
+  } finally { rmSync(temp, { force: true }); }
+}
+
+async function withShadowQueue<T>(cwd: string, deps: L8ShadowQueueDeps, fn: (state: L8ShadowQueueState, path: string) => Promise<T>): Promise<T> {
+  const release = await (deps.acquire ?? acquireL8MergeQueue)(cwd);
+  try {
+    const path = shadowQueuePath(cwd, deps.command ?? command);
+    return await fn(readShadowQueue(path), path);
+  } finally { release(); }
+}
+
+export function shadowPrNumber(raw: string): number {
+  const text = raw.replace(/^#/, '');
+  const number = Number(text);
+  if (!/^[1-9]\d*$/.test(text) || !Number.isSafeInteger(number)) throw new Error('expected a positive PR number');
+  return number;
+}
+
+export async function statusL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowQueueState> {
+  return withShadowQueue(cwd, deps, async (state) => state);
+}
+
+export async function enqueueL8ShadowQueue(cwd: string, number: number, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowQueueState> {
+  if (!Number.isSafeInteger(number) || number <= 0) throw new Error('expected a positive PR number');
+  return withShadowQueue(cwd, deps, async (state, path) => {
+    const execute = deps.command ?? command;
+    const view = JSON.parse(shadowCommand(execute, 'gh', ['pr', 'view', String(number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'], cwd)) as {
+      headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+    };
+    if (!view.headRefOid || !/^[0-9a-f]{40}$/i.test(view.headRefOid) || view.baseRefName !== 'main'
+      || view.state !== 'OPEN' || view.isDraft !== false || view.isCrossRepository !== false) throw new Error('PR is not an open, ready, same-repository main PR');
+    if (state.pending.some((p) => p.number === number)) throw new Error(`PR #${number} already queued`);
+    state.pending.push({ number, head: view.headRefOid });
+    writeShadowQueue(path, state);
+    return state;
+  });
+}
+
+/** Evaluate one pinned queue head against freshly fetched main. Never push or call a merge API. */
+export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}): Promise<L8ShadowVerdict | null> {
+  return withShadowQueue(cwd, deps, async (state, path) => {
+    const item = state.pending[0];
+    if (!item) return null;
+    const execute = deps.command ?? command;
+    const run = (bin: string, args: string[], where = cwd) => shadowCommand(execute, bin, args, where);
+    const verdict: L8ShadowVerdict = { number: item.number, head: item.head, verdict: 'fail', tests: [], at: new Date().toISOString() };
+    const view = JSON.parse(run('gh', ['pr', 'view', String(item.number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'])) as {
+      headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+    };
+    if (view.headRefOid !== item.head || view.baseRefName !== 'main' || view.state !== 'OPEN'
+      || view.isDraft !== false || view.isCrossRepository !== false) throw new Error('queued PR changed or is not ready');
+    run('git', ['fetch', 'origin', 'refs/heads/main']);
+    const base = run('git', ['rev-parse', 'FETCH_HEAD']);
+    if (!/^[0-9a-f]{40}$/i.test(base)) throw new Error('main commit unavailable');
+    verdict.base = base;
+    run('git', ['fetch', 'origin', `refs/pull/${item.number}/head`]);
+    if (run('git', ['rev-parse', 'FETCH_HEAD']) !== item.head) throw new Error('fetched PR head changed');
+    let temp: string | undefined;
+    let attached = false;
+    try {
+      temp = mkdtempSync(join(tmpdir(), 'elanous-l8-shadow-'));
+      run('git', ['worktree', 'add', '--detach', temp, base]);
+      attached = true;
+      const fork = run('git', ['merge-base', base, item.head], temp);
+      const changed = run('git', ['diff', '--name-only', '-z', fork, item.head], temp).split('\0').filter(Boolean);
+      if (!changed.length) throw new Error('PR changed-file paths unavailable');
+      const diff = run('git', ['diff', '--name-only', '-z', '--diff-filter=ACMRT', fork, item.head], temp);
+      const files = diff.split('\0').filter(Boolean);
+      if (changed.some((file) => file.startsWith('-') || file.startsWith('/') || file.split('/').includes('..') || file.includes('\\'))) throw new Error('unsafe changed-file path');
+      verdict.tests = files.filter((file) => /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/.test(file));
+      const merge = execute('git', ['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'merge', '--no-ff', '--no-edit', item.head], temp);
+      if (merge.status !== 0) {
+        const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp);
+        if (!unresolved) throw new Error(`git merge failed: ${merge.stderr.trim() || `exit ${merge.status}`}`);
+        verdict.verdict = 'conflict';
+        verdict.detail = unresolved;
+      } else {
+        if (verdict.tests.length) {
+          if (verdict.tests.some((file) => !existsSync(join(temp!, file)))) throw new Error('changed test path unavailable');
+          run('bun', ['install', '--frozen-lockfile'], temp);
+          const result = execute('bun', ['run', 'test:deterministic', ...verdict.tests], temp);
+          const output = `${result.stdout}\n${result.stderr}`;
+          const counts = /\b(\d+) pass\b[\s\S]*?\b(\d+) fail\b[\s\S]*?Ran ([1-9]\d*) tests? across ([1-9]\d*) files?/.exec(output);
+          if (!counts || Number(counts[1]) + Number(counts[2]) !== Number(counts[3])
+            || Number(counts[4]) !== verdict.tests.length || (result.status !== 0 && Number(counts[2]) === 0)) {
+            throw new Error(`changed tests unmeasured: ${output.slice(-400)}`);
+          }
+          if (Number(counts[2]) > 0 || Number(counts[1]) === 0) {
+            verdict.detail = `changed tests failed: ${output.slice(-400)}`;
+          } else {
+            verdict.verdict = 'pass';
+          }
+        } else {
+          verdict.verdict = 'pass';
+        }
+      }
+    } finally {
+      try {
+        if (attached && temp) run('git', ['worktree', 'remove', '--force', temp]);
+      } finally {
+        if (temp) rmSync(temp, { recursive: true, force: true });
+      }
+    }
+    if (verdict.verdict === 'pass') {
+      run('git', ['fetch', 'origin', 'refs/heads/main']);
+      if (run('git', ['rev-parse', 'FETCH_HEAD']) !== verdict.base) throw new Error('main advanced during shadow verification');
+      const current = JSON.parse(run('gh', ['pr', 'view', String(item.number), '--json', 'headRefOid,baseRefName,state,isDraft,isCrossRepository'])) as {
+        headRefOid?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean;
+      };
+      if (current.headRefOid !== item.head || current.baseRefName !== 'main' || current.state !== 'OPEN'
+        || current.isDraft !== false || current.isCrossRepository !== false) throw new Error('PR changed during shadow verification');
+    }
+    // A rejected insert leaves the pinned item queued for a later evaluation.
+    await (deps.observe ?? ((entry) => {
+      const store = getDefaultLogStore();
+      if (!store) throw new Error('merge-queue observation store unavailable');
+      store.insertBatch([{ rec: { ts: new Date().toISOString(), category: 'merge-queue', event: 'shadow-verdict', data: entry }, surface: 'merge-queue' }]);
+    }))(verdict);
+    state.pending.shift();
+    state.verdicts.push(verdict);
+    writeShadowQueue(path, state);
+    return verdict;
+  });
+}
+
 const command: Command = (bin, args, cwd) => {
   const r = spawnSync(bin, [...args], { cwd, encoding: 'utf8', timeout: 600_000, maxBuffer: 32 * 1024 * 1024 });
   return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error?.message ?? '') };

package/src/self-implement/orchestrator.ts

@@ -63,6 +63,7 @@ import { GoalRunStore, insertGoalRunRecord, type GoalPriorRuns } from './goal-ru
 import { writeGoalRunRecordFragment } from './goal-execution-records.js';
 import { getUserConfig } from '../user-config.js';
 import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
+import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { enqueueControlMemo, readSoftStopRequestStatus, type SoftStopRequestRead } from '../harness/control-inbox.js';
@@ -874,6 +875,8 @@ export type ImplementTerminalStatus = {
 export interface SelfImplementSeams {
   /** Run-observer ledger sink. Tests inject an in-memory sink to avoid touching user state. */
   writeRunLedger?: RunLedgerWriter;
+  /** Optional context-journal sink for isolated runs. */
+  emitContextEvent?: (input: SessionEventInput) => void;
   /** Registers this run as an ephemeral loop-agent asset; failures are observed but never affect execution. */
   registerLoopAgent?: (input: LoopAgentInput) => void;
   /** Wraps implementation and gate promises with their effective wall-clock timeout; tests observe the actual stage budgets. */
@@ -3384,6 +3387,16 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       detail: 'observe-only: SelfImplement execution skipped before child boot',
     };
   }
+  const emitContext = (kind: 'task-claimed' | 'task-done', text: string, pr?: number): void => {
+    try {
+      (opts.seams.emitContextEvent ?? emitSessionEvent)({ kind, seat: 'TC', text,
+        ref: `runId=${runId}${pr === undefined ? '' : ` PR=#${pr}`}` });
+    } catch (error) {
+      try { logRunAwareFailSoft(runId, 'context-event-failed', { kind, error: safeErrorDescription(error) }); }
+      catch { /* context publication never changes the run result */ }
+    }
+  };
+  emitContext('task-claimed', `Self-implement claimed: ${opts.feature.split(/\r?\n/, 1)[0]}`);
   const parentHarnessSpaceId = getHarnessSpace()?.id || undefined;
   const configRoot = getElanousConfigDir() || undefined;
   const stateRoot = elanousStateRoot() || undefined;
@@ -4091,6 +4104,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         }, { level: 'warn' });
       } catch { /* fail-soft — 종결 기록 실패가 원래 예외를 덮으면 안 된다 */ }
     }
+    emitContext('task-done', `Self-implement ${terminalResult?.stage ?? 'crashed'}: ${opts.feature.split(/\r?\n/, 1)[0]}`,
+      terminalResult?.prNumber ?? capturedPrNumber);
     finalizeTraversal();
     try { unregisterProviderErrorSink(); } catch { /* fail-soft — cleanup must not change the terminal result */ }
   }