elanous 0.2.20 → 0.2.22

package/src/self-implement/frozen-merges.ts

@@ -4,6 +4,8 @@ import { createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { enterJourneyNode, exitJourneyNode, passJourneyNode, withJourneyNodeSync } from '../self-dev/graph-journey-nodes.js';
+import { routeJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
@@ -183,6 +185,26 @@ export function admitLandingMerge(
   hooks: { afterQueue?: () => void } = {},
   claimKey?: { prNumber: number; repoRoot: string; headCommit?: string },
   opts: { prodFreezeRoot?: string; forceReason?: string } = {},
+): LandingAdmission {
+  // HARNESS-FULL-GRAPH — 병합 직전 한 곳의 동결 검사가 그래프 노드 freeze-check(출구: open | frozen | taken)이고,
+  // 동결이면 보류 대기열이 노드 hold 다. 판정은 바꾸지 않는다 — 관측만.
+  const pr = claimKey?.prNumber;
+  enterJourneyNode('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) });
+  const admission = withJourneyNodeSync('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) },
+    () => admitLandingMergeUnobserved(heldEntry, root, hooks, claimKey, opts));
+  const freezeLabel = admission.kind === 'merge' ? 'open' : admission.kind === 'held' ? 'frozen' : 'taken';
+  exitJourneyNode('freeze-check', { provenance: 'admit-landing-merge', outcome: freezeLabel, ...(pr === undefined ? {} : { data: { pr } }) });
+  // 2판: 간선 판독을 남긴다(관측). 승인 요구(open→hold) 강제는 0.2.22 — 보류 사유 값이 먼저다(RFC §3).
+  routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  return admission;
+}
+
+function admitLandingMergeUnobserved(
+  heldEntry: FrozenMerge | null | (() => FrozenMerge | null),
+  root: string,
+  hooks: { afterQueue?: () => void },
+  claimKey: { prNumber: number; repoRoot: string; headCommit?: string } | undefined,
+  opts: { prodFreezeRoot?: string; forceReason?: string },
 ): LandingAdmission {
   let entry: FrozenMerge | null | undefined;
   const prodFreezeRoot = opts.prodFreezeRoot ?? prodInstanceRoot();
@@ -223,6 +245,7 @@ export function admitLandingMerge(
     if (entry === undefined) entry = typeof heldEntry === 'function' ? heldEntry() : heldEntry; // only built when frozen
     if (!entry) return { kind: 'held', freeze: landing.frozen };
     queueFrozenMerge(entry, root);
+    passJourneyNode('hold', { provenance: 'admit-landing-merge', outcome: 'queued', data: { pr: entry.prNumber } });
     hooks.afterQueue?.();
     const afterQueue = beginLandingMerge(root, new Date(), prodFreezeRoot, opts.forceReason);
     if (afterQueue.frozen) return { kind: 'held', freeze: afterQueue.frozen };

package/src/self-implement/goal-author.ts

@@ -1363,6 +1363,20 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   return references;
 }
 
+/**
+ * AUTO-TARGET (10-08 canary · TSC-HEAP run-446cdc71): an authored goal whose `## PROBLEM` Situation line says
+ * NOT-GROUNDED has no persistent (Read-verified) evidence — `scqaNarrative` writes NOT-GROUNDED exactly when that
+ * channel is empty, and `## TRACED PATHS` then carries no path. Such a goal is a scope card, not an implementation
+ * goal: any target path it carries was not verified by grounding. Callers that know a path was machine-suggested
+ * (not written by the human) must not launch on it. Lite goals have no Situation line and return false.
+ */
+export function isNotGroundedWithoutPersistentEvidence(document: string): boolean {
+  const problem = markdownSection(document, 'PROBLEM');
+  if (problem === null) return false;
+  const situation = problem.split(/\r?\n/).find((line) => line.startsWith('Situation: '));
+  return situation !== undefined && situation.startsWith('Situation: NOT-GROUNDED') && tracedPathReferences(document).length === 0;
+}
+
 /** Inspect supplied goal text and branch name, optionally validating traced paths through an injected reader. */
 /**
  * Lint findings plus the number of inline invariant markers recognized for judgment candidates.

package/src/self-implement/harness-policy-gates.ts

@@ -5,16 +5,17 @@ import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-g
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runPublicExportLeakGate } from '../../scripts/ci-public-export-leak-gate.js';
+import { runPublicExportImportGate } from '../../scripts/ci-public-export-import-gate.js';
 
-type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak';
+type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak' | 'public-export-import';
 type GateOutput = { args: string[]; cwd: string; log: (line: string) => void; error: (line: string) => void };
-type GateRunner = (out: GateOutput) => number;
+type GateRunner = (out: GateOutput) => number | Promise<number>;
 
-export function runHarnessPolicyGates(input: {
+export async function runHarnessPolicyGates(input: {
   cwd: string;
   changedFiles: readonly string[];
   gates?: Partial<Record<GateName, GateRunner>>;
-}): { passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string } {
+}): Promise<{ passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string }> {
   try {
     if (!statSync(join(input.cwd, 'scripts')).isDirectory()) {
       return { passed: true, failures: [], skipped: 'no-scripts' };
@@ -30,12 +31,13 @@ export function runHarnessPolicyGates(input: {
     ['daemon-port-gate', input.gates?.['daemon-port-gate'] ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] }))],
     // LEAK1 — the same pre-export check as pr land; an unmeasured result is a nonzero failure, not a pass.
     ['public-export-leak', input.gates?.['public-export-leak'] ?? runPublicExportLeakGate],
+    ['public-export-import', input.gates?.['public-export-import'] ?? runPublicExportImportGate],
   ];
   const failures: Array<{ gate: GateName; lines: string[] }> = [];
   for (const [gate, run] of runners) {
     const lines: string[] = [];
     try {
-      const status = run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
+      const status = await run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
       if (status !== 0) failures.push({ gate, lines: [...lines, `✗ ${gate}: violation detected`] });
     } catch (error) {
       failures.push({ gate, lines: [...lines, `⚠ ${gate}: 게이트가 «못 쟀다» — ${error instanceof Error ? error.message : String(error)}`] });

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

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdir
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { getUserConfig } from '../user-config.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 
@@ -184,6 +185,8 @@ export function recordFailureEvent(event: FailureEvent, root = effectiveInstance
     return false;
   });
   debug.log('heal.intake', 'recorded', { source: event.source, kind: event.kind, ref: event.ref, folded });
+  // HARNESS-FULL-GRAPH — 하니스 런 실패 사건의 접수가 그래프 노드 heal 이다(출구: started | folded).
+  if (event.source === 'harness-run') passJourneyNode('heal', { provenance: 'heal-intake', outcome: folded ? 'folded' : 'started', data: { kind: event.kind, ref: event.ref } });
   if (!folded) {
     const runId = healRunId(event);
     void Promise.resolve().then(() => startLoop(HEAL_GRAPH, { runId, input: { failureEvent: event }, deps: { root } }))

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

@@ -8,7 +8,7 @@ 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';
+import { MAX_INSPECTED_TEST_FILES, runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 
 /**
  * The PWA's static build type-checks every `src/**` file it imports, under Next's stricter
@@ -22,9 +22,10 @@ export function needsPwaBuild(files: readonly string[]): boolean {
 
 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 InterferenceVerdict = { passed: boolean; detail?: string; unmeasured?: boolean; /** neighbour tests left out so the selection fits the inspection cap */ neighborsTrimmed?: number };
 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 }>;
+  interference?: (files: readonly string[], cwd: string) => Promise<InterferenceVerdict>;
   makeTemp?: () => string;
   removeTemp?: (path: string) => void;
   acquire?: (repoRoot: string) => Promise<() => void>;
@@ -46,17 +47,28 @@ const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd,
 };
 
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */
-async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean } = {}): Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }> {
-  const tests = files.filter((file) => /\.test\.tsx?$/.test(file));
-  const neighbors = new Set<string>(tests);
-  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃 시험을 넣으면 간섭 관문의 상한(8)에 잘려 영영 «측정 불가»가 되고,
-  //   이웃의 기존 실패가 이 PR 을 막는다(2026-09-28 #21239 실측: scripts/lib 이웃 9 → 상한 8 · nl-routing-measurement 기존 1 fail).
+export async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean; detect?: typeof detectTestInterference } = {}): Promise<InterferenceVerdict> {
+  const tests = [...new Set(files.filter((file) => /\.test\.tsx?$/.test(file)))].sort();
+  const changed = new Set(tests);
+  const neighbors = new Set<string>();
+  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃의 기존 실패가 이 PR 을 막지 않게
+  //   (2026-09-28 #21239 실측: scripts/lib 이웃 9 · nl-routing-measurement 기존 1 fail).
   if (opts.neighbors !== false) for (const file of tests) {
     for (const sibling of readdirSync(join(cwd, dirname(file)))) {
-      if (/\.test\.tsx?$/.test(sibling)) neighbors.add(join(dirname(file), sibling));
+      const path = join(dirname(file), sibling);
+      if (/\.test\.tsx?$/.test(sibling) && !changed.has(path)) neighbors.add(path);
     }
   }
-  const selected = [...neighbors].sort();
+  // 이웃이 간섭 관문의 상한(MAX_INSPECTED_TEST_FILES)을 넘기면 그 관문이 잘라 «영영 측정 불가»가 된다
+  //   (2026-10-08 #25180·#25187 실측: src/self-implement 시험 175 · src/seat-loop 11). 바뀐 시험은 전부 두고 남는 칸만 이웃으로 채운다.
+  //   바뀐 시험만으로 상한을 넘으면 정직하게 «측정 불가»로 남는다.
+  const sortedNeighbors = [...neighbors].sort();
+  const room = Math.max(0, MAX_INSPECTED_TEST_FILES - tests.length);
+  const kept = tests.length > MAX_INSPECTED_TEST_FILES ? sortedNeighbors : sortedNeighbors.slice(0, room);
+  const neighborsTrimmed = sortedNeighbors.length - kept.length;
+  const trimmed = neighborsTrimmed > 0 ? { neighborsTrimmed } : {};
+  const trimNote = neighborsTrimmed > 0 ? ` · neighbours trimmed ${neighborsTrimmed} to fit inspection cap ${MAX_INSPECTED_TEST_FILES}` : '';
+  const selected = [...tests, ...kept].sort();
   if (!selected.length) return { passed: true };
   // 간섭 관문은 시험 파일이 둘 이상일 때만 잰다 — 하나면 간섭이라는 말이 없으니 그 파일을 한 번 돌려 실패 수로 본다.
   if (selected.length === 1) {
@@ -69,13 +81,13 @@ async function defaultInterference(files: readonly string[], cwd: string, opts:
   let report: Awaited<ReturnType<typeof detectTestInterference>> | undefined;
   await runTestInterferenceGate({
     args: ['--changed-files', ...selected], log: () => {},
-    detect: async (paths) => (report = await detectTestInterference(paths, (batch) => runBunTest(batch, undefined, cwd))),
+    detect: async (paths) => (report = await (opts.detect ?? detectTestInterference)(paths, (batch) => runBunTest(batch, undefined, cwd))),
   });
-  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, detail: 'test interference measurement unavailable or truncated' };
+  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, ...trimmed, detail: `test interference measurement unavailable or truncated (selected ${selected.length}, changed tests ${tests.length}, cap ${MAX_INSPECTED_TEST_FILES})${trimNote}` };
   if (report.isolatedFailures !== 0 || report.combinedFailures !== 0 || report.status === 'interference') {
-    return { passed: false, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}` };
+    return { passed: false, ...trimmed, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}${trimNote}` };
   }
-  return { passed: true };
+  return { passed: true, ...trimmed, ...(trimNote ? { detail: trimNote.slice(3) } : {}) };
 }
 
 const SLOT_WAIT_MS = 30 * 60_000;
@@ -133,9 +145,10 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   let endLanding: ((merged?: boolean) => void) | undefined;
   let landed = false;
   let verifiedBase: string | undefined;
+  let interferenceNote: Record<string, unknown> = {};
   const result = (event: 'passed' | 'failed' | 'unmeasured', step?: string, detail?: string): HostRegateResult => {
     if (step) failures.push({ step, detail: detail ?? 'unknown' });
-    log(event, { pr: input.prNumber, files, os: process.platform, ...(step ? { failedStep: step } : {}) });
+    log(event, { pr: input.prNumber, files, os: process.platform, ...interferenceNote, ...(step ? { failedStep: step, detail: (detail ?? 'unknown').slice(0, 300) } : {}) });
     return { passed: event === 'passed', failures, os: process.platform, ...(input.verifyOnly ? { status: event, ...(verifiedBase ? { baseCommit: verifiedBase } : {}) } : {}) };
   };
   const run = (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): string => {
@@ -211,6 +224,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     } catch (e) { return result('unmeasured', 'worktree', String(e)); }
     try {
       const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, { neighbors: !input.verifyOnly })))(files, worktree);
+      if (interference.neighborsTrimmed) interferenceNote = { neighborsTrimmed: interference.neighborsTrimmed, interferenceDetail: (interference.detail ?? '').slice(0, 300) };
       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.

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

@@ -1,8 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, 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 { defaultLlmResolve, mergeMainWithLlmResolve, type MergeGitSeam } from '../autopilot/build/llm-conflict-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 };
@@ -30,7 +31,10 @@ export type L8MergeQueueDeps = {
 
 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> };
+export type L8ShadowQueueDeps = L8MergeQueueDeps & {
+  observe?: (verdict: L8ShadowVerdict) => void | Promise<void>;
+  resolveConflict?: (file: string, conflicted: string, target: string, worktree: string) => Promise<string>;
+};
 
 function shadowCommand(execute: Command, bin: string, args: string[], cwd: string): string {
   const result = execute(bin, args, cwd);
@@ -129,7 +133,8 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
       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);
-      let autoResolvedNextMd = false;
+      let integrated = merge.status === 0;
+      let resolvedNextMd = false;
       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.trim() || `exit ${merge.status}`}`);
@@ -148,14 +153,81 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
             writeFileSync(join(temp, NEXT_MD_PATH), resolved);
             run('git', ['add', '--', NEXT_MD_PATH], temp);
             run('git', ['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'commit', '-m', 'Integrate PR for L8 shadow evaluation'], temp);
-            autoResolvedNextMd = true;
+            resolvedNextMd = true;
+            integrated = true;
           }
         } else {
-          verdict.verdict = 'conflict';
-          verdict.detail = unresolved.join('\n');
+          const unsafe = unresolved.some((file) => file.startsWith('-') || file.startsWith('/') || file.split('/').includes('..') || file.includes('\\'));
+          if (unsafe) throw new Error('unsafe conflict path');
+          const staged = (stage: number, file: string): string | null => {
+            const result = execute('git', ['show', `:${stage}:${file}`], temp!);
+            return result.status === 0 ? result.stdout : null;
+          };
+          // Reject unsupported index shapes before consulting either resolver.
+          // A directory, submodule or unreadable path is an unsupported conflict shape, not an evaluator failure.
+          const hasTextMarkers = (file: string): boolean => {
+            try {
+              const path = join(temp!, file);
+              return existsSync(path) && statSync(path).isFile() && readFileSync(path, 'utf8').includes('<<<<<<< ');
+            } catch {
+              return false;
+            }
+          };
+          const unsupported = unresolved.some((file) => file !== NEXT_MD_PATH && !hasTextMarkers(file));
+          // A non-append-only next.md conflict must not fall through to the LLM even when other files conflict.
+          const nextStages = !unsupported && unresolved.includes(NEXT_MD_PATH)
+            ? [staged(1, NEXT_MD_PATH), staged(2, NEXT_MD_PATH), staged(3, NEXT_MD_PATH)] as const
+            : undefined;
+          const nextMd = nextStages
+            ? nextStages.some((value) => value === null) ? null
+              : resolveNextMdConflict(nextStages[0]!, nextStages[1]!, nextStages[2]!)
+            : undefined;
+          if (unsupported || nextMd === null || unresolved.some((file) => file !== NEXT_MD_PATH
+            && (staged(1, file) === null || staged(2, file) === null || staged(3, file) === null))) {
+            verdict.verdict = 'conflict';
+            verdict.detail = nextMd === null ? 'release/next.md conflict is not append-only' : unresolved.join('\n');
+          } else {
+            const git = (args: string[]) => execute('git', args, temp!);
+            const mergeGit: MergeGitSeam = {
+              isConfiguredRemote: () => false, // item.head is the fetched, pinned commit, not a remote branch.
+              fetch: () => false,
+              merge: () => ({ ok: false, conflict: true, stdout: merge.stdout, errorDetail: merge.stderr.trim() }),
+              conflictedFiles: () => run('git', ['diff', '--name-only', '--diff-filter=U'], temp!).split('\n').filter(Boolean),
+              readIndexStage: (_wt, stage, file) => {
+                const result = git(['show', `:${stage}:${file}`]);
+                if (result.status !== 0) throw new Error(`index stage ${stage} unavailable: ${file}`);
+                return result.stdout;
+              },
+              readFile: (file) => readFileSync(file, 'utf8'),
+              writeFile: (file, content) => writeFileSync(file, content),
+              add: (_wt, file) => { run('git', ['add', '--', file], temp!); },
+              commit: () => {
+                const result = git(['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'commit', '-m', 'Integrate PR for L8 shadow evaluation']);
+                return { ok: result.status === 0, errorDetail: result.stderr.trim() };
+              },
+              abort: () => { run('git', ['merge', '--abort'], temp!); },
+            };
+            const resolved = await mergeMainWithLlmResolve(temp, item.head, async (file, conflicted) => {
+              if (file === NEXT_MD_PATH) {
+                const next = resolveNextMdConflict(mergeGit.readIndexStage(temp!, 1, file), mergeGit.readIndexStage(temp!, 2, file), mergeGit.readIndexStage(temp!, 3, file));
+                if (next === null) throw new Error('release/next.md conflict is not append-only');
+                return next;
+              }
+              return (deps.resolveConflict ?? ((path, content, target, worktree) => defaultLlmResolve(path, content, target, { worktreePath: worktree, mode: 'on' })))(file, conflicted, item.head, temp!);
+            }, mergeGit);
+            if (resolved.status === 'conflict-unresolved') {
+              verdict.verdict = 'conflict';
+              verdict.detail = resolved.failedFile === NEXT_MD_PATH ? 'release/next.md conflict is not append-only'
+                : `${resolved.failedFile ?? 'merge conflict'}: ${resolved.reason ?? 'context resolution failed'}`;
+            } else if (resolved.status === 'error') {
+              throw new Error(`git merge failed: ${resolved.errorStep}: ${resolved.errorDetail ?? 'unknown error'}`);
+            }
+            integrated = resolved.status === 'llm-resolved';
+            resolvedNextMd = integrated && resolved.resolvedFiles?.includes(NEXT_MD_PATH) === true;
+          }
         }
       }
-      if (merge.status === 0 || autoResolvedNextMd) {
+      if (integrated) {
         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);
@@ -174,7 +246,7 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
         } else {
           verdict.verdict = 'pass';
         }
-        if (autoResolvedNextMd) {
+        if (resolvedNextMd) {
           verdict.detail = verdict.detail ? `release/next.md auto-resolved; ${verdict.detail}` : 'release/next.md auto-resolved';
         }
       }