elanous 0.2.10 → 0.2.12

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-cli.ts

@@ -15,16 +15,19 @@ import { resolveGateScope } from './gate-scope.js';
 import { debug } from '../debug/log.js';
 import { buildDocumentGuardianIndex, formatDocumentGuardians } from './document-guardian-index.js';
 import { buildImporterTestIndex, isTestPath, type ImporterTestIndex } from './importer-test-index.js';
+import { buildRouteConsumerTestIndex } from './route-consumer-test-index.js';
 import { gitChangedFiles, observeGateBaselineLocation } from './seams.js';
 import {
   collectBaseLandingCommits,
   overlapWithCurrentChanges,
 } from '../cli/pr-granularity.js';
 import { listWorktrees } from '../git-fs/worktree.js';
+import { runShardedGateTests } from '../self-dev/shard-run.js';
 
 interface SelfGateCliOptions {
   base?: string;
   pr?: string;
+  shards?: number;
 }
 
 interface ProcessResult {
@@ -74,6 +77,7 @@ interface SelfGateCliDeps {
   readFile?: (path: string) => string | undefined;
   runTests?: (cwd: string, files: readonly string[]) => ProcessResult;
   runBaseline?: (cwd: string, files: readonly string[], baseRef: string) => BaselineProcessResult;
+  runShards?: typeof runShardedGateTests;
   runIsolationGate?: (out: GateOutput) => number;
   runMockModuleRestoreGate?: (out: GateOutput) => number;
   /** 모델 이름 하드코딩 래칫(🅕 #20521) — `pr land` 만 물고 하니스 무인 병합은 안 물면 위반이 main 에 들어가 남의 착지를 막는다(🅣 2026-09-25). */
@@ -571,11 +575,16 @@ function logGateCliBaseline(cwd: string, payload: GateCliBaselinePayload): void
 
 export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, deps: SelfGateCliDeps = {}): SelfGateCliResult {
   if (options.base && options.pr) throw new Error('use either --base <ref> or --pr <number>, not both');
+  if (options.shards !== undefined && (!Number.isSafeInteger(options.shards) || options.shards < 1)) throw new Error('invalid --shards count');
   const selection = (deps.changedFiles ?? ((dir, input) => defaultChangedFiles(dir, input, deps.runCommand)))(cwd, options);
   const exists = deps.exists ?? ((path) => existsSync(`${cwd}/${path}`));
   const importerIndex = buildGateImporterTestIndex(selection.files, cwd, deps.runCommand);
   const lookupFailed = importerIndex && 'lookupFailed' in importerIndex ? importerIndex.lookupFailed : undefined;
-  const scope = resolveGateScope(selection.files, exists, importerIndex && !('lookupFailed' in importerIndex) ? importerIndex : undefined);
+  const availableIndex = importerIndex && !('lookupFailed' in importerIndex) ? importerIndex : undefined;
+  const routeIndex = availableIndex?.testPaths
+    ? buildRouteConsumerTestIndex(cwd, availableIndex.testPaths, selection.files, selection.baseRef) : null;
+  const scope = resolveGateScope(selection.files, exists, availableIndex,
+    { routeConsumerTestIndex: routeIndex ?? undefined });
   const testFiles = [...(scope.testArgs ?? [])];
   const unrunImporterTotal = lookupFailed ? null : (scope.importerTestsNotRun?.total ?? 0);
   const importerLookupFailed = Boolean(lookupFailed);
@@ -601,6 +610,9 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     // 🚨 러너 우주 «밖» — 형제들과 같은 정책으로 «말만» 한다(`OBS-T418`).
     formatUnrunnableChangeKinds(selection.files),
     formatUnrunImporterTests(scope.importerTestsNotRun, lookupFailed),
+    `caller tests: ${lookupFailed ? `lookup failed (${lookupFailed})` : scope.callerTests.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ') || (routeIndex?.lookupFailures.length ? 'route lookup incomplete' : '(none)')}`,
+    ...(routeIndex?.lookupFailures.length ? [`⚠️ caller route base lookup failed — unmeasured: ${routeIndex.lookupFailures.map(({ source, reason }) => `${source} (${reason})`).join(', ')}`] : []),
+    ...(scope.callerTestsOverflow.length ? [`⚠️ caller test cap exceeded — not run: ${scope.callerTestsOverflow.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ')}`] : []),
     changedTestCountNote(cwd, selection.files, selection.baseRef, deps.runCommand, deps.readFile),
   ];
   if (options.pr) {
@@ -629,6 +641,33 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
+  if (options.shards !== undefined) {
+    const sharded = (deps.runShards ?? runShardedGateTests)(cwd, testFiles, selection.baseRef, options.shards);
+    lines.push(`shards: ${sharded.shards.length} (${sharded.shards.map((shard) => `${shard.id}=${shard.files.join(',')}`).join('; ')})`);
+    for (const attempt of sharded.attempts) lines.push(`shard attempt: ${attempt.shardId} #${attempt.attempt}`);
+    const { aggregate } = sharded;
+    if (aggregate.status === 'unmeasured') lines.push(`shards: unmeasured (${aggregate.retryShardIds.join(', ') || sharded.reason || 'no complete JUnit'})`);
+    else if (aggregate.report) {
+      const report = aggregate.report;
+      logGateCliBaseline(cwd, {
+        introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown,
+        preconditionUnmet: report.preconditionUnmet, timedOut: report.timedOut,
+        timeoutPassedAtBase: report.timeoutPassedAtBase, failures: report.failures.slice(0, 20),
+        baselineFiles: report.files, baselineStatus: report.baselineStatus, unrunImporterTotal, lookupFailed: importerLookupFailed,
+      });
+      lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, formatGateBaselineNote(report, unrunImporterTotal ?? 0)));
+    } else {
+      lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, `tests: pass (${testFiles.length} files)`));
+      logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
+    }
+    const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
+    return {
+      exitCode: aggregate.status !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed ? 1 : 0,
+      lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
+      documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
+    };
+  }
+
   const test = (deps.runTests ?? ((dir, files) => (deps.runCommand ?? defaultRunCommand)('bun', ['test', ...files], dir)))(cwd, testFiles);
   const worktreeLog = formatProcessOutput(test);
   if (test.status === 0 && !test.error) {

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

@@ -29,6 +29,11 @@
 //      → 유도 결과는 **반드시 존재하는 파일**이어야 한다.
 
 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';
 
 /** 테스트 파일 판정(기존 `seams.ts` 정규식과 동일 — 어휘 분기 금지). */
 const TEST_RE = /\.(test|spec)\.[cm]?[tj]sx?$/;
@@ -245,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: {
@@ -258,6 +259,10 @@ interface GateScopeDecision {
     readonly truncated: boolean;
     readonly unresolvedRelativeSpecifiers: number;
   } | null;
+  /** Selected reverse-dependent tests and why they were pulled into the gate. */
+  readonly callerTests: readonly { readonly file: string; readonly reasons: readonly GateCallerReason[] }[];
+  /** Caller tests exceeding the cap, retained in full for warning and diagnosis. */
+  readonly callerTestsOverflow: readonly { readonly file: string; readonly reasons: readonly GateCallerReason[] }[];
 }
 
 /**
@@ -274,7 +279,7 @@ export function resolveGateScope(
   changed: readonly string[],
   exists: (path: string) => boolean,
   importerTestIndex?: ImporterTestIndex,
-  opts?: { mode?: GateScopeMode; isDeleted?: (path: string) => boolean },
+  opts?: { mode?: GateScopeMode; isDeleted?: (path: string) => boolean; routeConsumerTestIndex?: RouteConsumerTestIndex },
 ): GateScopeDecision {
   // ⚠️ **실존 검증(리뷰 must-fix 4R)** — `gitChangedFiles` 는 `git diff --name-only HEAD` 라
   //   **삭제·rename 前 경로도 포함**한다. 그걸 그대로 `testArgs` 로 넘기면 필터가 아무것도 매치하지
@@ -328,18 +333,43 @@ export function resolveGateScope(
   const observationFor = (runSet: readonly string[]) => importerTestIndex
     ? importerTestsNotInRunSet(importerTestIndex, userChanged, runSet)
     : null;
-  const base = { sourceFiles, documentPaths, ignoredOutsideSrc, missingTestFiles, elanousRuntimeArtifacts,
+  const conventional = deriveRelatedTests(userChanged, exists);
+  const alreadySelected = new Set([...testFiles, ...conventional]);
+  const callers = new Map<string, Set<GateCallerReason>>();
+  for (const source of userChanged) {
+    for (const [reason, tests] of [
+      ['import', importerTestIndex?.testsBySource.get(source) ?? []],
+      ['route', opts?.routeConsumerTestIndex?.testsBySource.get(source) ?? []],
+    ] as const) {
+      for (const test of tests) {
+        if (!exists(test) || alreadySelected.has(test)) continue;
+        const reasons = callers.get(test) ?? new Set<GateCallerReason>();
+        reasons.add(reason);
+        callers.set(test, 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)])];
+  const base = { sourceFiles, documentPaths, ignoredOutsideSrc, missingTestFiles, elanousRuntimeArtifacts, callerTests, callerTestsOverflow,
     unverified: [] as readonly string[], derived: [] as readonly string[], pulledInRelatedTests: [] as readonly string[] };
   const withDocumentNonContribution = (runSet: readonly string[]) => ({
     documentsWithoutDerivedTests: documentsWithoutDerivedTestsFor(runSet),
   });
 
   if (testFiles.length > 0) {
-    const allRelatedTests = deriveRelatedTests(userChanged, exists);
-    const runSet = [...new Set([...testFiles, ...allRelatedTests])];
+    // 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를 읽는다.
@@ -348,9 +378,10 @@ export function resolveGateScope(
   if (nonDoc.length === 0) {
     return { ...base, ...withDocumentNonContribution([]), importerTestsNotRun: observationFor([]), skipTestStep: true, reason: 'docs-only' };
   }
-  const derived = deriveRelatedTests(userChanged, exists);
-  if (derived.length > 0) {
-    return { ...base, ...withDocumentNonContribution(derived), derived, testArgs: derived, unverified: unverifiedFor(derived), importerTestsNotRun: observationFor(derived), skipTestStep: false, reason: 'derived' };
+  const derived = conventional;
+  const runSet = runWithCallers(derived);
+  if (runSet.length > 0) {
+    return { ...base, ...withDocumentNonContribution(runSet), derived, testArgs: runSet, unverified: unverifiedFor(runSet), importerTestsNotRun: observationFor(runSet), skipTestStep: false, reason: 'derived' };
   }
   // 실행 집합이 비었으므로 비문서 전부가 미검증이다.
   return { ...base, ...withDocumentNonContribution([]), unverified: unverifiedFor([]), importerTestsNotRun: observationFor([]), skipTestStep: true, reason: 'no-related-tests' };

package/src/self-implement/graph-variant.ts

@@ -0,0 +1,171 @@
+import { createHash } from 'node:crypto';
+import { applyGraphOverlays, type GraphOverlaySpec, type OverlayPatchOp, type OverlayRejection } from './graph-overlay-yaml.js';
+import { edgeMapOf, graphVersionHash, type GraphEdgeSpec, type GraphNodeSpec, type GraphTemplateSpec } from './graph-yaml.js';
+import { inspectPipelineGraph } from './pipeline-shape.js';
+import { hasNodeKind } from '../graph-kinds/registry.js';
+
+/** A proposed change to one existing outcome of a conditional route. Unconditional and fallback edges are protected. */
+export interface GraphVariantRoute {
+  readonly from: string;
+  readonly outcome: string;
+  readonly to: string;
+}
+
+export interface GraphVariantGrowth {
+  readonly node: GraphNodeSpec;
+  readonly from: string;
+  readonly outcome: string;
+  readonly returnTo?: string;
+}
+
+export interface GraphVariantPlan {
+  readonly maxVisits?: Readonly<Record<string, number>>;
+  readonly routes?: readonly GraphVariantRoute[];
+  readonly growth?: GraphVariantGrowth;
+}
+
+export type GraphVariantRejection =
+  | { readonly kind: 'invalid-goal' }
+  | { readonly kind: 'unknown-node'; readonly node: string }
+  | { readonly kind: 'invalid-budget'; readonly node: string; readonly value: number }
+  | { readonly kind: 'protected-edge'; readonly from: string; readonly outcome: string }
+  | { readonly kind: 'unknown-outcome'; readonly from: string; readonly outcome: string }
+  | { readonly kind: 'duplicate-route'; readonly from: string; readonly outcome: string }
+  | { readonly kind: 'ambiguous-outcome'; readonly from: string; readonly outcome: string }
+  | { readonly kind: 'unreachable-terminal'; readonly node: string }
+  | { readonly kind: 'invalid-graph'; readonly defects: ReturnType<typeof inspectPipelineGraph> }
+  | { readonly kind: 'overlay-rejected'; readonly rejections: readonly OverlayRejection[] }
+  | { readonly kind: 'invalid-growth'; readonly reason: string };
+
+export type GraphVariantResult =
+  | { readonly ok: true; readonly overlay: GraphOverlaySpec; readonly template: GraphTemplateSpec; readonly patches: readonly OverlayPatchOp[] }
+  | { readonly ok: false; readonly rejections: readonly GraphVariantRejection[] };
+
+/** Pure, deterministic variant authoring. Never mutates the supplied template and never writes an overlay. */
+export function createGraphVariant(input: {
+  readonly template: GraphTemplateSpec;
+  readonly goal: string;
+  readonly plan: GraphVariantPlan;
+}): GraphVariantResult {
+  const { template, goal, plan } = input;
+  const known = new Set(template.nodes.map((node) => node.nodeId));
+  const rejections: GraphVariantRejection[] = [];
+  if (!/^g_[a-z0-9_-]+$/i.test(goal)) rejections.push({ kind: 'invalid-goal' });
+  if (plan.growth) {
+    const { node, from, outcome, returnTo } = plan.growth;
+    if (!node || typeof node !== 'object') return { ok: false, rejections: [{ kind: 'invalid-growth', reason: 'growth requires one new contracted node' }] };
+    const edgeIndex = template.edges.findIndex((edge) => edge.from === from);
+    const edge = template.edges[edgeIndex];
+    if (!known.has(from) || known.has(node.nodeId) || template.terminalNodes.includes(from) ||
+        typeof node.nodeId !== 'string' || !node.nodeId || typeof node.recipe !== 'string' || !node.recipe ||
+        typeof node.kind !== 'string' || !hasNodeKind('harness', node.kind) || !Number.isSafeInteger(node.maxVisits) || node.maxVisits < 1 ||
+        typeof node.contract?.tools !== 'string' || !node.contract.tools.trim() || !Array.isArray(node.contract.inputs) ||
+        !Array.isArray(node.contract.outputs) || typeof outcome !== 'string' || !outcome || !edge || edge.to !== undefined || edge.on !== 'outcome' ||
+        !edge.map || Object.hasOwn(edge.map, outcome) ||
+        template.edges.filter((candidate) => candidate.from === from).length !== 1 ||
+        typeof returnTo !== 'string' || !known.has(returnTo) || plan.routes?.length || Object.keys(plan.maxVisits ?? {}).length) {
+      rejections.push({ kind: 'invalid-growth', reason: 'growth requires one new contracted node, one missing conditional outcome and an existing return destination' });
+    }
+    if (rejections.length) return { ok: false, rejections };
+    const addedEdge: GraphEdgeSpec = { from: node.nodeId, to: returnTo as string };
+    const patches: OverlayPatchOp[] = [
+      { op: 'add', path: '/nodes/-', value: node },
+      { op: 'add', path: `/edges/${edgeIndex}/map/${outcome.replace(/~/g, '~0').replace(/\//g, '~1')}`, value: node.nodeId },
+      { op: 'add', path: '/edges/-', value: addedEdge },
+    ];
+    const normalized = JSON.stringify({ graph: graphVersionHash(template), goal, patches });
+    const overlay: GraphOverlaySpec = { overlayId: `variant-${createHash('sha256').update(normalized).digest('hex').slice(0, 16)}`,
+      target: template.graphId, stage: 'runtime', appliesWhen: `goal_key == ${goal}`, patch: patches };
+    // Existing YAML runner nodes predate contracts; only the newly proposed node must supply one.
+    const validationTemplate: GraphTemplateSpec = { ...template, nodes: template.nodes.map((existing) => ({
+      ...existing, contract: existing.contract?.tools ? existing.contract : { inputs: [], tools: 'existing', outputs: [] },
+    })) };
+    const applied = applyGraphOverlays(validationTemplate, [overlay]);
+    if (!applied.ok) return { ok: false, rejections: [{ kind: 'overlay-rejected', rejections: applied.rejections }] };
+    const projected: GraphTemplateSpec = { ...applied.template, nodes: [...template.nodes, node] };
+    const edges = edgeMapOf(projected);
+    const reached = new Set<string>();
+    const pending = [projected.entryNode];
+    while (pending.length) {
+      const at = pending.pop()!;
+      if (reached.has(at)) continue;
+      reached.add(at);
+      pending.push(...(edges[at] ?? []));
+    }
+    const unreachable = projected.terminalNodes.filter((terminal) => !reached.has(terminal) || (edges[terminal]?.length ?? 0) !== 0);
+    if (unreachable.length) return { ok: false, rejections: unreachable.map((terminal) => ({ kind: 'unreachable-terminal', node: terminal })) };
+    return { ok: true, overlay, template: projected, patches };
+  }
+  const patches: OverlayPatchOp[] = [];
+
+  for (const [node, value] of Object.entries(plan.maxVisits ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    if (!known.has(node)) { rejections.push({ kind: 'unknown-node', node }); continue; }
+    if (!Number.isSafeInteger(value) || value < 1) { rejections.push({ kind: 'invalid-budget', node, value }); continue; }
+    const index = template.nodes.findIndex((candidate) => candidate.nodeId === node);
+    if (template.nodes[index]!.maxVisits !== value) patches.push({ op: 'replace', path: `/nodes/${index}/maxVisits`, value });
+  }
+
+  const seen = new Set<string>();
+  for (const route of [...(plan.routes ?? [])].sort((a, b) => {
+    const left = JSON.stringify([a.from, a.outcome, a.to]);
+    const right = JSON.stringify([b.from, b.outcome, b.to]);
+    return left < right ? -1 : left > right ? 1 : 0;
+  })) {
+    if (!known.has(route.from)) { rejections.push({ kind: 'unknown-node', node: route.from }); continue; }
+    if (!known.has(route.to)) { rejections.push({ kind: 'unknown-node', node: route.to }); continue; }
+    const key = JSON.stringify([route.from, route.outcome]);
+    if (seen.has(key)) { rejections.push({ kind: 'duplicate-route', from: route.from, outcome: route.outcome }); continue; }
+    seen.add(key);
+    const matches = template.edges.filter((edge) => edge.from === route.from && edge.map && Object.hasOwn(edge.map, route.outcome));
+    // One patch addresses one edge, so an outcome declared on two conditional edges would validate a graph we do not return.
+    if (matches.length > 1) { rejections.push({ kind: 'ambiguous-outcome', from: route.from, outcome: route.outcome }); continue; }
+    const conditional = matches[0];
+    if (!conditional) {
+      const protectedEdge = template.edges.some((edge) => edge.from === route.from && (edge.to !== undefined || edge.fallback?.length));
+      rejections.push(protectedEdge
+        ? { kind: 'protected-edge', from: route.from, outcome: route.outcome }
+        : { kind: 'unknown-outcome', from: route.from, outcome: route.outcome });
+      continue;
+    }
+    const index = template.edges.indexOf(conditional);
+    if (conditional.map![route.outcome] !== route.to) {
+      // JSON Pointer escaping keeps even unusual, already-declared outcome labels addressable.
+      const label = route.outcome.replace(/~/g, '~0').replace(/\//g, '~1');
+      patches.push({ op: 'replace', path: `/edges/${index}/map/${label}`, value: route.to });
+    }
+  }
+  if (rejections.length > 0) return { ok: false, rejections };
+
+  const projected: GraphTemplateSpec = {
+    ...template,
+    nodes: template.nodes.map((node) => ({ ...node, maxVisits: plan.maxVisits?.[node.nodeId] ?? node.maxVisits })),
+    edges: template.edges.map((edge) => edge.map === undefined ? edge : {
+      ...edge,
+      map: Object.fromEntries(Object.entries(edge.map).map(([outcome, to]) => [outcome,
+        plan.routes?.find((route) => route.from === edge.from && route.outcome === outcome)?.to ?? to])),
+    }),
+  };
+  const edges = edgeMapOf(projected);
+  const defects = inspectPipelineGraph(edges, projected.entryNode);
+  const reached = new Set<string>();
+  const pending = [projected.entryNode];
+  while (pending.length) {
+    const node = pending.pop()!;
+    if (reached.has(node)) continue;
+    reached.add(node);
+    for (const to of edges[node] ?? []) pending.push(to);
+  }
+  const unreachable = projected.terminalNodes.filter((node) => !reached.has(node) || (edges[node]?.length ?? 0) !== 0);
+  if (unreachable.length > 0) return { ok: false, rejections: unreachable.map((node) => ({ kind: 'unreachable-terminal', node })) };
+  if (defects.length > 0) return { ok: false, rejections: [{ kind: 'invalid-graph', defects }] };
+  const normalized = JSON.stringify({ graph: graphVersionHash(template), goal, patches });
+  const overlayId = `variant-${createHash('sha256').update(normalized).digest('hex').slice(0, 16)}`;
+  const overlay: GraphOverlaySpec = { overlayId, target: template.graphId, stage: 'launch', appliesWhen: `goal_key == ${goal}`, patch: patches };
+  // Existing runner YAML nodes may predate contracts; the plan only changes routes and visits.
+  const validationTemplate: GraphTemplateSpec = { ...template, nodes: template.nodes.map((node) => ({
+    ...node, contract: node.contract?.tools ? node.contract : { inputs: [], tools: 'existing', outputs: [] },
+  })) };
+  const applied = applyGraphOverlays(validationTemplate, [overlay]);
+  if (!applied.ok) return { ok: false, rejections: [{ kind: 'overlay-rejected', rejections: applied.rejections }] };
+  return { ok: true, overlay, template: projected, patches };
+}

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

@@ -28,7 +28,7 @@ export function runHarnessPolicyGates(input: {
     ['mock-module-restore-gate', input.gates?.['mock-module-restore-gate'] ?? runMockModuleRestoreGate],
     ['model-hardcode-gate', input.gates?.['model-hardcode-gate'] ?? runModelHardcodeGate],
     ['daemon-port-gate', input.gates?.['daemon-port-gate'] ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] }))],
-    // LEAK1 — the check release prepare fails on, before the harness lands (0.2.7: a mark in a test title).
+    // 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],
   ];
   const failures: Array<{ gate: GateName; lines: string[] }> = [];

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

@@ -58,11 +58,13 @@ import { childRunContextEnv, childProviderKeyEnv, childLlmSelectionEnv, type Chi
 import { childToolProfile } from '../agent/tool-profile.js';
 import { escalationAllowedForProvider } from './rework-policy.js';
 import { getUserConfig, resolveActiveProvider, resolveRoleLlm } from '../user-config.js';
+import { goalDifficultySignals, classifyGoalDifficulty, resolveImplementDifficulty } from '../llm/difficulty.js';
 import { childNestEnv } from '../agent/nest-depth.js';
 import { childPtyIdentityEnv } from '../agent/pty-identity.js';
 import { elanousTuiSpawnOptions } from './elanous-tui-spawn.js';
 import { describeGrokCredentialFreshness, readGrokTokenFreshness, type GrokCredentialFreshnessSnapshot } from '../acp/grok-auth.js';
 import { debug } from '../debug/log.js';
+import { observeExternalEvent } from '../context-bus/external-events.js';
 import { sendOutbound } from '../domains/outbound-alert.js';
 import { formatPtyLinkMessage, readReportOrigin } from './report-origin.js';
 import { DETACHED_PROGRESS_FRAME_PREFIX, decodeDetachedProgressFrame } from '../harness/dispatch-detached.js';
@@ -920,6 +922,8 @@ export interface HeadlessGoalLoopPtyOptions {
   cwd: string;
   /** 이미 featurePrompt() 적용된 프롬프트(범위제한·클린빌드 앵커 포함). */
   featurePrompt: string;
+  /** Original goal document before the execution prompt is decorated. */
+  goalDocument?: string;
   configDir?: string;
   /** ★ K run-identity — 이 실행이 속한 per-run join anchor. 미지정 시 상속(env) → 없으면 canonical mint
    *  (`perCallRunId`). 호출자(runSelfImplement)가 지정하면 **리워크 라운드가 하나의 runId 를 공유**해
@@ -1164,14 +1168,30 @@ export interface HeadlessGoalLoopPtyResult {
   ptyId: string;
 }
 
+export function pickImplementRoleForGoal(document: string): ReturnType<typeof resolveRoleLlm> | undefined {
+  try {
+    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 });
+      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; }
+}
+
 export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions): Promise<HeadlessGoalLoopPtyResult> {
   const childLlm = opts.childLlm;
   if (childLlm && (typeof childLlm.provider !== 'string' || typeof childLlm.model !== 'string' || !childLlm.provider.trim() || !childLlm.model.trim())) {
     throw new Error('childLlm.provider and childLlm.model must both be non-empty');
   }
-  // ⭐ B14 — 역할 `implement` 해석(명시 자식 LLM · 런 단위 모델이 없을 때만). 실패하면 종전(주 모델 상속)으로.
+  // ⭐ B14 — 명시 자식 LLM · 런 단위 모델이 없을 때 골 난이도에 따라 역할 `implement` 기본 등급을 고른다.
   const implementRole = !childLlm && !process.env.ELANOUS_LLM_MODEL?.trim()
-    ? (() => { try { return resolveRoleLlm('implement'); } catch { return undefined; } })()
+    ? pickImplementRoleForGoal(opts.goalDocument ?? opts.featurePrompt)
     : undefined;
   // ⭐ B9 — 승급 판정에 쓸 «유효 provider»: 명시 자식 → 역할 → 런 env → config(auto 는 실제 결정으로).
   const effectiveChildProvider = childLlm?.provider ?? implementRole?.provider ?? process.env.ELANOUS_LLM_PROVIDER?.trim()
@@ -1202,6 +1222,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
   const controlInboxDir = resolveControlInboxDir(space.id);
   const { key: screenKey } = resolveHarnessScreenKey(space.id, opts.cwd);
   const executionId = mintPtyId('self');
+  const contextSource = `elanous://harness/${encodeURIComponent(runId)}/${encodeURIComponent(executionId)}`;
   const boundaryRequestsEnv = harnessBoundaryRequestsEnv(executionId);
   const boundaryResponsesEnv = harnessBoundaryResponsesEnv(executionId);
   const boundaryRequestsPath = boundaryRequestsEnv.ELANOUS_HARNESS_BOUNDARY_REQUESTS ?? '';
@@ -1213,6 +1234,8 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
   const emitDone = (data: Record<string, unknown>): void => {
     if (doneEmitted) return;
     doneEmitted = true;
+    if (spawned) observeExternalEvent({ origin: 'harness-child', kind: 'finished',
+      summary: `Harness child finished: ${String(data.exitReason ?? 'unknown').slice(0, 60)}`, source: contextSource });
     debug.log('self-implement', 'headless.done', {
       ptyId: executionId,
       runId,
@@ -1326,7 +1349,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
       ...(space ? harnessSpaceEnv(space.kind, space.id, runId) : {}),   // 자식 goal-loop 자기인지(#4948 프리앰블) + ★K runId 명시 전파(captured-env 경계)
       ...harnessBoundaryEnv(opts.cwd),   // ★ #4 명시 쓰기 경계 — worktree(cwd) 전파 → 자식 부팅 시 결정론 경계 활성(정본 오염 봉쇄)
       ...(opts.documentReferences?.length ? { ELANOUS_DOCUMENT_REFERENCES: JSON.stringify(opts.documentReferences) } : {}),
-      // ⭐ BACKLOG B14 (대표 2026-09-25) — 명시 자식 LLM 도 런 단위 모델(`ELANOUS_LLM_MODEL`)도 없으면 역할 `implement`(better)로 고른다.
+      // ⭐ B14/E2 — 명시 자식 LLM·런 단위 모델이 없으면 골 난이도를 적용한 구현 역할 모델을 릴레이한다.
       ...childLlmSelectionEnv(childLlm ?? (implementRole ? { provider: implementRole.provider, model: implementRole.model, source: 'config' } : undefined)),
       // 결정 2026-09-23 — 명시 childLlm 은 «같은 provider» 사다리 안에서만 한 칸 승급한다(없으면 승급 안 함).
       //   미지정 경로는 기존 티어(codex sol 등)를 그대로 쓴다.
@@ -1351,6 +1374,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
     },
     });
     spawned = true;
+    observeExternalEvent({ origin: 'harness-child', kind: 'started', summary: 'Harness child started', source: contextSource });
     phase = 'initialization';
   const ptyId = h.id;
   // ⭐⭐ M5 — 그 판정을 «런 슈퍼바이저 레코드»로 올린다. 종전엔 경계 판정이 자기 로그에만 남아

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

@@ -3,6 +3,7 @@ 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 { 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';
 
@@ -158,6 +159,26 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
       base = run('git', ['merge-base', baseCommit, input.headCommit], worktree);
       files = run('git', ['diff', '--name-only', base, input.headCommit], worktree).split('\n').filter(Boolean);
       if (!files.length) throw new Error('changed files unavailable');
+      if (!input.verifyOnly) {
+        // --name-only lists only the destination of a rename. Inspect both sides without
+        // changing the gate's existing changed-file list or its test selection.
+        const guardPaths = releaseGitDiffPaths(run('git', ['diff', '--find-renames', '--name-status', '-z', base, input.headCommit], worktree));
+        const heldPath = releasePathHold(guardPaths);
+        if (heldPath) {
+          debug.log('self-dev.merge', 'release-path-hold', { number: input.prNumber, path: heldPath, label: RELEASE_PATH_LABEL, surface: 'host-regate' });
+          try {
+            const existing: unknown = JSON.parse(run('gh', ['label', 'list', '--search', RELEASE_PATH_LABEL, '--json', 'name'], input.repoRoot));
+            if (!Array.isArray(existing)) throw new Error('invalid label list');
+            if (!existing.some((item: unknown) => !!item && typeof item === 'object' && 'name' in item && item.name === RELEASE_PATH_LABEL)) {
+              run('gh', ['label', 'create', RELEASE_PATH_LABEL, '--color', 'D93F0B', '--description', 'Release path requires OP approval'], input.repoRoot);
+            }
+            run('gh', ['pr', 'edit', String(input.prNumber), '--add-label', RELEASE_PATH_LABEL], input.repoRoot);
+          } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number: input.prNumber, action: 'label', error: String(error) }); }
+          try { if (releasePathHoldShouldPost(() => JSON.parse(run('gh', releasePathHoldCommentsArgs(input.prNumber), input.repoRoot)))) run('gh', ['pr', 'comment', String(input.prNumber), '--body', releasePathHoldComment(heldPath)], input.repoRoot); }
+          catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number: input.prNumber, action: 'comment', error: String(error) }); }
+          return result('failed', 'release-path-hold', `OP approval required: ${heldPath}`);
+        }
+      }
       // Materialize the proposed merge of this exact PR head into the observed base.
       // A clean head checkout cannot expose integration breaks introduced by the base.
       try { run('git', ['merge', '--no-ff', '--no-commit', input.headCommit], worktree); }
@@ -234,7 +255,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
     try { release?.(); }
     catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'lock', detail: String(e) }); }
-    if (failures.length) {
+    if (failures.length && failures[0]?.step !== 'release-path-hold') {
       const { step, detail } = failures[0]!;
       const body = `호스트 재게이트 실패(${process.platform}): ${step} — ${detail.replace(/\s+/g, ' ').slice(0, 180)}`;
       try { run('gh', ['pr', 'comment', String(input.prNumber), '--body', body], input.repoRoot); }

package/src/self-implement/importer-test-index.ts

@@ -6,6 +6,7 @@ const IMPORTER_TEST_DISPLAY_LIMIT = 20;
 
 export interface ImporterTestIndex {
   readonly testsBySource: ReadonlyMap<string, readonly string[]>;
+  readonly testPaths?: readonly string[];
   readonly unresolvedRelativeSpecifiers: number;
 }
 
@@ -105,7 +106,7 @@ export function buildImporterTestIndex(cwd: string, testPaths: readonly string[]
       testsBySource.set(source, importers);
     }
   }
-  return { testsBySource, unresolvedRelativeSpecifiers };
+  return { testsBySource, testPaths, unresolvedRelativeSpecifiers };
 }
 
 export function importerTestsNotInRunSet(