elanous 0.2.13 → 0.2.15

package/src/self-implement/heal-intake.ts

@@ -0,0 +1,197 @@
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
+
+export type FailureSource = 'release-run' | 'harness-run' | 'loop-tick' | 'cron';
+
+export interface FailureEvent {
+  source: FailureSource;
+  kind: string;
+  ref: string;
+  summary: string;
+  at: string;
+}
+
+const FOLD_WINDOW_MS = 60 * 60 * 1_000;
+const HEAL_GRAPH = join(import.meta.dir, '../../graphs/heal/heal-loop.yaml');
+
+type HealLoopOptions = { runId: string; input: { failureEvent: FailureEvent }; deps: { root: string } };
+type StartHealLoop = (file: string, options: HealLoopOptions) => Promise<unknown>;
+
+function healRunId(event: FailureEvent): string {
+  return `heal-${createHash('sha256').update(JSON.stringify([event.source, event.ref, event.at])).digest('hex')}`;
+}
+
+function maxConcurrentLoops(): number {
+  const raw = getUserConfig().raw.heal;
+  const cap = raw && typeof raw === 'object' && !Array.isArray(raw)
+    ? (raw as Record<string, unknown>).maxConcurrentLoops : undefined;
+  return typeof cap === 'number' && Number.isSafeInteger(cap) && cap > 0 ? cap : 2;
+}
+
+function ownerAlive(pid: unknown, pidStartedAt: unknown): boolean {
+  if (!Number.isSafeInteger(pid) || (pid as number) <= 0 || typeof pidStartedAt !== 'string') return false;
+  const started = Date.parse(pidStartedAt);
+  if (!Number.isFinite(started)) return false;
+  try {
+    const actual = psProcessStartMs(pid as number);
+    return actual !== null && Number.isFinite(actual) && Math.abs(actual - started) <= START_TOLERANCE_MS;
+  } catch { return false; }
+}
+
+function liveHealRuns(root: string): Set<string> {
+  const live = new Set<string>();
+  const dir = join(root, 'graph-runs', 'heal-loop');
+  let files: string[];
+  try { files = readdirSync(dir); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return live;
+    throw error;
+  }
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    try {
+      const state = JSON.parse(readFileSync(join(dir, file), 'utf8')) as Record<string, unknown>;
+      if (state.graphId === 'heal-loop' && state.runId === file.slice(0, -5) &&
+          state.status === 'running' && ownerAlive(state.pid, state.pidStartedAt)) live.add(state.runId as string);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT' && !(error instanceof SyntaxError)) throw error;
+    }
+  }
+  return live;
+}
+
+/** A test process must never start the real heal loop — it spawns external grounding (10-05 load 150 incident). */
+export async function startHealLoop(file: string, options: HealLoopOptions, env: NodeJS.ProcessEnv = process.env,
+  run: StartHealLoop = async (graph, args) => (await import('../graph-runner/runner.js')).runGraph(graph, args)): Promise<unknown> {
+  if (env.NODE_ENV === 'test' || env.ELANOUS_TEST_HOME) {
+    debug.log('heal.intake', 'loop-start-skipped-test', { runId: options.runId });
+    return undefined;
+  }
+  const root = options.deps.root;
+  const claimDir = join(root, 'heal', 'starts');
+  const selected = withInboxLock(inboxPath(root), () => {
+    mkdirSync(claimDir, { recursive: true });
+    const live = liveHealRuns(root);
+    const claimed = new Set<string>();
+    for (const name of readdirSync(claimDir)) {
+      if (!/^heal-[a-f0-9]{64}\.json$/.test(name)) continue;
+      const runId = name.slice(0, -5);
+      const path = join(claimDir, name);
+      const claim = JSON.parse(readFileSync(path, 'utf8')) as { active?: boolean; started?: boolean; pid?: number; pidStartedAt?: string };
+      const owner = claim.active && ownerAlive(claim.pid, claim.pidStartedAt);
+      if (!owner && !claim.started && !existsSync(join(root, 'graph-runs', 'heal-loop', `${runId}.json`))) {
+        unlinkSync(path);
+        continue;
+      }
+      claimed.add(runId);
+      if (owner && !live.has(runId)) live.add(runId);
+    }
+    const cap = maxConcurrentLoops();
+    if (live.size >= cap) {
+      debug.log('heal.intake', 'loop-start-deferred', { running: live.size, cap, runId: options.runId });
+      return undefined;
+    }
+    const next = readInbox(inboxPath(root)).find(event => !claimed.has(healRunId(event)) &&
+      !existsSync(join(root, 'graph-runs', 'heal-loop', `${healRunId(event)}.json`)));
+    if (!next) return undefined;
+    const runId = healRunId(next);
+    writeFileSync(join(claimDir, `${runId}.json`), JSON.stringify({ active: true, pid: process.pid,
+      pidStartedAt: new Date(Date.now() - process.uptime() * 1_000).toISOString() }), { flag: 'wx' });
+    return { event: next, runId };
+  });
+  if (!selected) return undefined;
+  let started = false;
+  try {
+    const result = await run(file, { runId: selected.runId, input: { failureEvent: selected.event }, deps: { root } });
+    started = true;
+    return result;
+  } finally {
+    withInboxLock(inboxPath(root), () => {
+      const claim = join(claimDir, `${selected.runId}.json`);
+      if (started || existsSync(join(root, 'graph-runs', 'heal-loop', `${selected.runId}.json`))) {
+        writeFileSync(claim, JSON.stringify({ active: false, started: true }));
+      } else {
+        unlinkSync(claim);
+      }
+    });
+    // A completed run opens a slot; a pre-ledger failure waits for the next intake rather than retrying in a tight loop.
+    if (started) void Promise.resolve().then(() => startHealLoop(file, options, env, run)).catch(error => {
+      debug.log('heal.intake', 'loop-start-failed', { runId: selected.runId, error: String(error) }, { level: 'error' });
+    });
+  }
+}
+
+function inboxPath(root: string): string {
+  return join(root, 'heal', 'inbox.jsonl');
+}
+
+function readInbox(file: string): FailureEvent[] {
+  let content: string;
+  try { content = readFileSync(file, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return content.split('\n').filter(Boolean).map(line => JSON.parse(line) as FailureEvent);
+}
+
+/** Lock the read/fold/append transaction across processes, not just within one runner. */
+function withInboxLock<T>(file: string, work: () => T): T {
+  mkdirSync(dirname(file), { recursive: true });
+  const lock = `${file}.lock`;
+  const deadline = Date.now() + 5_000;
+  for (;;) {
+    try { mkdirSync(lock); break; }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > 60_000) {
+          rmdirSync(lock);
+          continue;
+        }
+      } catch (cause) {
+        if ((cause as NodeJS.ErrnoException).code !== 'ENOENT') throw cause;
+      }
+      if (Date.now() >= deadline) throw new Error(`heal inbox lock is held: ${file}`);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  try { return work(); }
+  finally { rmdirSync(lock); }
+}
+
+/** One durable JSON line per failure; repeat source+ref within an hour is folded. */
+export function recordFailureEvent(event: FailureEvent, root = effectiveInstanceRoot(), startLoop: StartHealLoop = startHealLoop): { folded: boolean } {
+  if (!['release-run', 'harness-run', 'loop-tick', 'cron'].includes(event.source) ||
+      !event.kind || !event.ref || !event.summary || !Number.isFinite(Date.parse(event.at))) {
+    throw new Error('invalid heal failure event');
+  }
+  const file = inboxPath(root);
+  const folded = withInboxLock(file, () => {
+    const incoming = Date.parse(event.at);
+    if (readInbox(file).some(previous => previous.source === event.source && previous.ref === event.ref &&
+      incoming - Date.parse(previous.at) >= 0 && incoming - Date.parse(previous.at) < FOLD_WINDOW_MS)) return true;
+    appendFileSync(file, JSON.stringify(event) + '\n');
+    return false;
+  });
+  debug.log('heal.intake', 'recorded', { source: event.source, kind: event.kind, ref: event.ref, folded });
+  if (!folded) {
+    const runId = healRunId(event);
+    void Promise.resolve().then(() => startLoop(HEAL_GRAPH, { runId, input: { failureEvent: event }, deps: { root } }))
+      .catch(error => {
+        debug.log('heal.intake', 'loop-start-failed', { source: event.source, kind: event.kind, ref: event.ref, runId, error: String(error) }, { level: 'error' });
+      });
+  }
+  return { folded };
+}
+
+export function readFailureInbox({ since }: { since?: string } = {}, root = effectiveInstanceRoot()): FailureEvent[] {
+  const threshold = since === undefined ? -Infinity : Date.parse(since);
+  if (Number.isNaN(threshold)) throw new Error('invalid heal inbox since');
+  return readInbox(inboxPath(root)).filter(event => Date.parse(event.at) >= threshold);
+}

package/src/self-implement/host-regate.ts

@@ -3,6 +3,9 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync,
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { publicExposureFiles, runExposeGate } from './expose-gate.js';
+import { admitLandingMerge } from './frozen-merges.js';
 import { releaseGitDiffPaths, releasePathHold, releasePathHoldShouldPost, releasePathHoldComment, releasePathHoldCommentsArgs, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
 import { detectTestInterference, parseFailureCount, runBunTest } from '../../scripts/detect-test-interference.js';
 import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
@@ -17,8 +20,8 @@ export function needsPwaBuild(files: readonly string[]): boolean {
   return files.some((file) => file.startsWith('apps/pwa/') || (file.startsWith('src/') && !/\.test\.tsx?$/.test(file)));
 }
 
-export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; verifyOnly?: boolean }
-export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
+export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; goalFile?: string; verifyOnly?: boolean; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
+export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured' | 'frozen'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
 export type HostRegateDeps = {
   command?: (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
   interference?: (files: readonly string[], cwd: string) => Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }>;
@@ -26,6 +29,9 @@ export type HostRegateDeps = {
   removeTemp?: (path: string) => void;
   acquire?: (repoRoot: string) => Promise<() => void>;
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
+  freezeRoot?: string;
+  runExposeGate?: typeof runExposeGate;
+  syncMergedChecklist?: typeof import('../release-loop/merged-pr-checklist.js').syncMergedPrChecklist;
 };
 
 const SPAWN_MAX_BUFFER = 256 * 1024 * 1024;
@@ -122,6 +128,8 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   let worktree: string | undefined;
   let attached = false;
   let release: (() => void) | undefined;
+  let endLanding: ((merged?: boolean) => void) | undefined;
+  let landed = false;
   let verifiedBase: string | undefined;
   const result = (event: 'passed' | 'failed' | 'unmeasured', step?: string, detail?: string): HostRegateResult => {
     if (step) failures.push({ step, detail: detail ?? 'unknown' });
@@ -203,6 +211,13 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
       const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, { neighbors: !input.verifyOnly })))(files, worktree);
       if (!interference.passed) return result(interference.unmeasured ? 'unmeasured' : 'failed', 'test-interference', interference.detail);
     } catch (e) { return result('unmeasured', 'test-interference', String(e)); }
+    // Landing can also be initiated by the host after the child gate; judge the checked PR here too.
+    if (publicExposureFiles(files).length > 0) {
+      const exposure = (deps.runExposeGate ?? runExposeGate)(worktree, files,
+        getUserConfig().harness?.exposeGate === 'strict' ? 'strict' : 'warn',
+        (bin, args, dir) => command(bin, args, dir));
+      if (!exposure.passed) return result('failed', 'expose', exposure.log);
+    }
     // verifyOnly: 통합 후보는 «지금 main 끝»(baseCommit)에 얹은 것이다 — 옛 merge-base 로 비교하면 그사이 main 착지분
     //   수백 파일이 «이 PR 의 변경»으로 잡혀 저장소 전체 검사로 승격된다(2026-09-28 #21239 실측: 456파일 · PWA 636건).
     try { run('bun', ['scripts/ci-typecheck-changed.ts'], worktree, { ...process.env, TSC_BASE_REF: input.verifyOnly ? baseCommit : base }); }
@@ -226,6 +241,13 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     // --match-head-commit pins the head. gh has no base pin, so the base was re-read just
     // above; the seconds between that read and the merge are checked after the fact below.
     if (input.verifyOnly) return result('passed');
+    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit });
+    if (landing.kind !== 'merge') {
+      debug.log('harness.merge', 'frozen', { pr: input.prNumber, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
+      return { passed: true, failures: [], os: process.platform, status: 'frozen' };
+    }
+    // The marker and claim are held through the merge «and» its confirmation; released in the outer finally.
+    endLanding = landing.end;
     try { run('gh', ['pr', 'merge', String(input.prNumber), '--squash', '--match-head-commit', input.headCommit], input.repoRoot); }
     catch (e) { return result('failed', 'merge', String(e)); }
     type MergedView = { state?: string; mergeCommit?: { oid?: string } | null };
@@ -233,6 +255,13 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     try { merged = JSON.parse(run('gh', ['pr', 'view', String(input.prNumber), '--json', 'state,mergeCommit'], input.repoRoot)); }
     catch (e) { return result('unmeasured', 'merge-confirm', String(e)); }
     if (merged.state !== 'MERGED') return result('unmeasured', 'merge-confirm', `PR state after merge is ${merged.state ?? 'unknown'}`);
+    landed = true;
+    try {
+      const sync = deps.syncMergedChecklist ?? (await import('../release-loop/merged-pr-checklist.js')).syncMergedPrChecklist;
+      sync(input.prNumber, input.repoRoot, input.goalFile);
+    } catch (error) {
+      debug.log('release.checklist', 'merged-pr-sync-failed', { pr: input.prNumber, error: String(error) });
+    }
     const mergeCommit = merged.mergeCommit?.oid ?? '';
     let mergedOnto = '';
     try {
@@ -249,6 +278,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   } catch (e) {
     return result('unmeasured', 'host-regate', String(e));
   } finally {
+    try { endLanding?.(landed); } catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'landing-release', detail: String(e) }); }
     try { if (attached && worktree) run('git', ['worktree', 'remove', '--force', worktree], input.repoRoot); }
     catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
     try { if (worktree) (deps.removeTemp ?? ((path) => rmSync(path, { recursive: true, force: true })))(worktree); }

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

@@ -8,6 +8,20 @@ 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 };
 export type L8MergeQueueResult = { merged: boolean; baseRefName?: string; mergeCommit?: string; detail?: string };
+/** Read-only integration report. Never a landing decision and never a remote write. */
+export type L8ChangedTestResult = { file: string; passed: boolean; pass: number; fail: number; detail?: string };
+export type L8IntegrationEvaluation = {
+  number: number;
+  head: string;
+  base?: string;
+  /** True only when the candidate integrates (next.md-only conflicts resolved) and every changed test passed. */
+  feasible: boolean;
+  conflictingFiles: string[];
+  /** True when there is no conflict, or every conflict path is exactly release/next.md. */
+  conflictsLimitedToNextMd: boolean;
+  changedTests: L8ChangedTestResult[];
+  detail?: string;
+};
 export type L8MergeQueueDeps = {
   command?: Command;
   /** Must identify the same shared repository across all harness processes. */
@@ -195,6 +209,124 @@ export async function acquireL8MergeQueue(cwd: string): Promise<() => void> {
   }
 }
 
+const TEST_PATH = /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/;
+
+function parseChangedTestCounts(output: string): { pass: number; fail: number; ran: number; files: number } | null {
+  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) return null;
+  return { pass: Number(counts[1]), fail: Number(counts[2]), ran: Number(counts[3]), files: Number(counts[4]) };
+}
+
+/**
+ * Report whether one pinned PR can integrate onto freshly fetched main.
+ * Resolves an append-only release/next.md conflict in a disposable worktree only.
+ * Never pushes, never calls a merge API, and never moves a remote ref.
+ */
+export async function evaluateL8Integration(input: L8MergeQueueInput, deps: L8MergeQueueDeps = {}): Promise<L8IntegrationEvaluation> {
+  const report: L8IntegrationEvaluation = {
+    number: input.number,
+    head: input.matchHeadCommit,
+    feasible: false,
+    conflictingFiles: [],
+    conflictsLimitedToNextMd: false,
+    changedTests: [],
+  };
+  if (!Number.isSafeInteger(input.number) || input.number <= 0 || !/^[0-9a-f]{40}$/i.test(input.matchHeadCommit)) {
+    return { ...report, detail: 'invalid PR number or pinned head' };
+  }
+  const execute = deps.command ?? command;
+  const run = (bin: string, args: readonly 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();
+  };
+  const refuseRemote = (bin: string, args: readonly string[]) => {
+    if (bin === 'git' && args.some((arg) => arg === 'push' || arg === 'update-ref')) throw new Error('evaluation must not push');
+    if (bin === 'gh' && args.some((arg) => arg === 'merge')) throw new Error('evaluation must not merge');
+  };
+  const guarded: Command = (bin, args, cwd) => {
+    refuseRemote(bin, args);
+    return execute(bin, args, cwd);
+  };
+  let temp: string | undefined;
+  let attached = false;
+  try {
+    type View = { headRefOid?: string; headRefName?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean };
+    const view = JSON.parse(run('gh', ['pr', 'view', String(input.number), '--json', 'headRefOid,headRefName,baseRefName,state,isDraft,isCrossRepository'], input.cwd)) as View;
+    if (view.headRefOid !== input.matchHeadCommit || view.baseRefName !== 'main' || view.state !== 'OPEN' || view.isDraft !== false || view.isCrossRepository !== false) {
+      throw new Error('PR head, base, or ready/open state changed');
+    }
+    run('git', ['fetch', 'origin', 'refs/heads/main'], input.cwd);
+    const base = run('git', ['rev-parse', 'FETCH_HEAD'], input.cwd);
+    if (!/^[0-9a-f]{40}$/i.test(base)) throw new Error('main commit unavailable');
+    report.base = base;
+    run('git', ['fetch', 'origin', `refs/pull/${input.number}/head`], input.cwd);
+    if (run('git', ['rev-parse', 'FETCH_HEAD'], input.cwd) !== input.matchHeadCommit) throw new Error('fetched PR head changed');
+    temp = mkdtempSync(join(tmpdir(), 'elanous-l8-eval-'));
+    run('git', ['worktree', 'add', '--detach', temp, input.matchHeadCommit], input.cwd);
+    attached = true;
+    const fork = run('git', ['merge-base', base, input.matchHeadCommit], temp);
+    const paths = run('git', ['diff', '--name-only', '-z', fork, input.matchHeadCommit], temp).split('\0').filter(Boolean);
+    if (!paths.length) throw new Error('PR changed-file paths unavailable');
+    if (paths.some((path) => path.startsWith('-') || path.startsWith('/') || path.split('/').includes('..') || path.includes('\\'))) throw new Error('unsafe PR changed-file path');
+    const livePaths = run('git', ['diff', '--name-only', '-z', '--diff-filter=ACMRT', fork, input.matchHeadCommit], temp).split('\0').filter(Boolean);
+    const tests = livePaths.filter((path) => TEST_PATH.test(path));
+    const merge = guarded('git', ['-c', 'user.name=elanous merge queue', '-c', 'user.email=queue@localhost', 'merge', '--no-ff', '--no-edit', base], temp);
+    if (merge.status !== 0) {
+      const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp).split('\n').filter(Boolean);
+      if (!unresolved.length) throw new Error(`git merge failed: ${(merge.stderr || `exit ${merge.status}`).trim()}`);
+      report.conflictingFiles = unresolved;
+      report.conflictsLimitedToNextMd = unresolved.length === 1 && unresolved[0] === NEXT_MD_PATH;
+      if (!report.conflictsLimitedToNextMd) {
+        report.detail = `merge conflicts: ${unresolved.join(', ')}`;
+        return report;
+      }
+      const stage = (n: number): string => {
+        const result = guarded('git', ['show', `:${n}:${NEXT_MD_PATH}`], temp!);
+        if (result.status !== 0) throw new Error(`release/next.md stage ${n} unavailable: ${result.stderr}`);
+        return result.stdout;
+      };
+      const resolved = resolveNextMdConflict(stage(1), stage(3), stage(2));
+      if (resolved === null) {
+        report.feasible = false;
+        report.detail = 'release/next.md conflict is not append-only';
+        return report;
+      }
+      writeFileSync(join(temp, NEXT_MD_PATH), resolved);
+      run('git', ['add', '--', NEXT_MD_PATH], temp);
+      run('git', ['-c', 'user.name=elanous merge queue', '-c', 'user.email=queue@localhost', 'commit', '-m', 'Integrate latest main for L8 evaluation'], temp);
+    } else {
+      report.conflictsLimitedToNextMd = true;
+    }
+    if (tests.length) {
+      const unavailable = tests.filter((path) => !existsSync(join(temp!, path)));
+      if (unavailable.length) throw new Error(`changed test paths unavailable: ${unavailable.join(', ')}`);
+      run('bun', ['install', '--frozen-lockfile'], temp);
+      for (const file of tests) {
+        const result = guarded('bun', ['test', file], temp);
+        const output = `${result.stdout}\n${result.stderr}`;
+        const counts = parseChangedTestCounts(output);
+        if (!counts || counts.pass + counts.fail !== counts.ran || counts.files !== 1 || (result.status !== 0 && counts.fail === 0)) {
+          throw new Error(`changed tests unmeasured: ${output.slice(-400)}`);
+        }
+        const passed = result.status === 0 && counts.fail === 0 && counts.pass > 0;
+        report.changedTests.push({ file, passed, pass: counts.pass, fail: counts.fail, ...(passed ? {} : { detail: output.slice(-400) }) });
+      }
+      if (report.changedTests.some((entry) => !entry.passed)) {
+        report.detail = 'changed tests failed';
+        return report;
+      }
+    }
+    report.feasible = true;
+    return report;
+  } catch (error) {
+    return { ...report, feasible: false, detail: String(error) };
+  } finally {
+    if (attached && temp) execute('git', ['worktree', 'remove', '--force', temp], input.cwd);
+    if (temp) rmSync(temp, { recursive: true, force: true });
+  }
+}
+
 /** One PR per shared git directory, integrated on a freshly fetched main in a disposable worktree. */
 export async function runL8MergeQueue(input: L8MergeQueueInput, deps: L8MergeQueueDeps = {}): Promise<L8MergeQueueResult> {
   if (!Number.isSafeInteger(input.number) || input.number <= 0 || !/^[0-9a-f]{40}$/i.test(input.matchHeadCommit)) {