elanous 0.2.34 → 0.2.36

package/src/self-implement/orchestrator.ts

@@ -40,6 +40,7 @@ import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import { hostname, loadavg } from 'node:os';
 import { resolveHostId } from '../platform/host-id.js';
 import { resolveInstanceName } from '../instance-identity.js';
+import { ghAutomationEnv } from '../autopilot/pr-manager.js';
 import { citedReviewSymbols, MAX_CITED_REVIEW_SYMBOL_CHARS, measureReviewFindingKeyOverlap, normalizeReviewFindingKey, REVIEW_FINDING_KEY_VERSION, reviewFindingKey, shortNormalizedReviewFindingHash, type CitedReviewSymbol } from '../agent-substrate/review-finding-key.js';
 export { citedReviewSymbols, MAX_CITED_REVIEW_SYMBOL_CHARS, normalizeReviewFindingKey, REVIEW_FINDING_KEY_VERSION, reviewFindingKey, shortNormalizedReviewFindingHash, type CitedReviewSymbol } from '../agent-substrate/review-finding-key.js';
 
@@ -47,6 +48,46 @@ function displayBranchName(ref: string): string {
   return ref.trim().replace(/^refs\/heads\//, '').replace(/^origin\//, '');
 }
 
+export const HARVEST_DEFERRED_MARKER = '수확보류: harvest-deferred';
+const execFileAsync = promisify(execFileCallback);
+
+export function markHarvestDeferredBody(input: {
+  runStatus: string | undefined;
+  prNumber: number | undefined;
+  body: string | undefined;
+}): string | undefined {
+  if (input.runStatus !== 'failed' || input.prNumber === undefined || !Number.isSafeInteger(input.prNumber) || input.prNumber < 1 || input.body === undefined) return undefined;
+  if (harvestDeferredMarker(input.body)) return input.body;
+  const separator = input.body.endsWith('\n') ? '\n' : '\n\n';
+  return `${input.body}${separator}${HARVEST_DEFERRED_MARKER}`;
+}
+
+export async function readHarvestPrBody(opts: { number: number; cwd: string }): Promise<{ body: string; state: string; isDraft: boolean } | undefined> {
+  const { stdout } = await execFileAsync('gh', ['pr', 'view', String(opts.number), '--json', 'body,state,isDraft'], {
+    cwd: opts.cwd,
+    env: ghAutomationEnv(process.env),
+    encoding: 'utf8',
+    timeout: 120_000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  const parsed: unknown = JSON.parse(stdout);
+  if (!parsed || typeof parsed !== 'object') return undefined;
+  const record = parsed as { body?: unknown; state?: unknown; isDraft?: unknown };
+  return typeof record.body === 'string' && typeof record.state === 'string' && typeof record.isDraft === 'boolean'
+    ? { body: record.body, state: record.state, isDraft: record.isDraft }
+    : undefined;
+}
+
+export async function updateHarvestPrBody(opts: { number: number; body: string; cwd: string }): Promise<void> {
+  await execFileAsync('gh', ['pr', 'edit', String(opts.number), '--body', opts.body], {
+    cwd: opts.cwd,
+    env: ghAutomationEnv(process.env),
+    encoding: 'utf8',
+    timeout: 120_000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+}
+
 export function formatAutoMergeSuccessMessage(input: {
   prNumber: number;
   mergedBase?: string | undefined;
@@ -79,6 +120,7 @@ import { classifyGateEnvDeficit, DEFAULT_GATE_ENV_RETRY, GATE_ENV_DEFICIT_HARVES
 import { recordFailureEvent } from './heal-intake.js';
 import { classifyReworkCapExhaustion, type ReworkCapHealDecision } from './heal-triage.js';
 import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
+import { harvestDeferredMarker } from '../self-dev/draft-triage-rules.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { reworkDecision } from './decision-events.js';
 import type { LogSink } from '../mss/logging/sink.js';
@@ -91,7 +133,7 @@ import { classifyError } from '../session-runtime/retry-policy.js';
 import { decomposeSelfDevGoal, inferHotPaths, type SelfDevDecomposeOptions } from '../self-dev/decompose.js';
 import { boundaryGlobs, boundaryViolations } from './goal-boundary.js';
 import { askAtExecution, type ExecutionClarificationResult } from './execution-clarification.js';
-import { classifyOutOfScope } from './scope-adjacency.js';
+import { decideScopeExpansion, renderScopeExpansionSection, SCOPE_EXPANSION_CAP, type ScopeExpansion, type ScopeStopReason } from './scope-adjacency.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import { selectKnowhowPack } from './knowhow-pack.js';
 import { declaredNewFilePaths } from './goal-new-paths.js';
@@ -108,6 +150,7 @@ import { originObservationFields } from '../agent/origin-observation.js';
 import { resolveLaunchStamp, type LaunchStamp } from '../harness/launch-stamp.js';
 import { getHarnessSpace, normalizeSpaceId, resolveRunIdentity } from '../harness/harness-space.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { addNextMdReleaseNote, harnessReleaseNote, parseReleaseNoteSection, releaseNotesDir, renderReleaseNoteSection, writeReleaseNote, type ReleaseNoteFragment, type ReleaseNoteSection } from '../release-loop/release-note.js';
 import { landingFreezeMessage } from '../release-loop/landing-freeze.js';
@@ -182,7 +225,8 @@ import { formatGateFailedId, type PremiseReviewCard, type PremiseReviewInput } f
 import { runWorkflowToCompletion } from '../workflow-runtime/executor.js';
 import { mapReworkVerdict, supervisionObservationFields } from './supervision-vocabulary.js';
 import { resolveRunOutcome } from './run-outcome.js';
-import { authorLimitationCountFromGoal, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, requiredEvidenceFromGoal, runRequiredEvidenceChecks, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { authorLimitationCountFromGoal, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, requiredEvidenceFromGoal, createRequiredEvidenceBudget, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { resolveEvidenceHeadCommit } from './evidence-command-budget.js';
 import { pressDecisionSignals, type DecisionSignalPressResult } from './decision-signal-press.js';
 import { inspectDecisionObservations, inspectDecisionSignalKinds, inspectDecisionSignalObservations } from '../../scripts/ask-marker-check.js';
 
@@ -256,8 +300,9 @@ import type { ClassifyShadowCallLLM } from './classify-shadow.js';
 import { hasModuleLoadFailure, type GateTestFailure } from './gate-baseline.js';
 import { commitWorktree, defaultBranchRef, preservationHasChanges } from './seams.js';
 import { detectUncommittedWork } from './uncommitted-work.js';
-import { spawnSync } from 'node:child_process';
-import { blockedDraftDisposition, decideDraftOnStop, nextMoveFor, parseDraftOnStopMode, salvageBranchForRun, type DraftOnStopMode } from './blocked-draft-policy.js';
+import { execFile as execFileCallback, spawnSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import { blockedDraftDisposition, blockedDraftTargetFor, decideDraftOnStop, nextMoveFor, parseDraftOnStopMode, repairSalvageLinkComment, salvageBranchForRun, syntheticRepairBasePr, type DraftOnStopMode } from './blocked-draft-policy.js';
 import { formatLlmMergeOutcome } from '../autopilot/build/llm-conflict-merge.js';
 import { FOUND_CITED_PATH_REFUTATION_QUOTE, MISSING_CITED_PATH_REFUTATION_QUOTE, MUST_FIX_REFUTATION_ACKNOWLEDGEMENT_WITH_REASON, REFUTATION_QUOTE_GRAMMAR, observeMustFixCitedPaths, parseMustFixRefutationAcknowledgement, parseMustFixRefutations, renderMustFixCitedPathFacts, snapshotMustFixFindings, stableMustFixId, type ReflectEvidenceFacts, type ReflectGateFacts, type MustFixCitedPathFact, type MustFixFinding, type MustFixRecurrenceHistory, type MustFixRefutation, type MustFixRefutationKind } from './reflect-mustfix.js';
 import type { IngestionEntry } from '../agent-substrate/execution/ingestion-policy.js';
@@ -279,7 +324,8 @@ import { AMBIGUOUS_STAGES, checkPipelineTraversal, nodesForStage, pipelineGraphI
 import { appendGateWorktreeFreshnessEvidence, gateEvidenceNote } from '../harness/review-adapter.js';
 import { diffHeaderPaths } from '../agent-substrate/self-review-cli.js';
 import { format as formatPrComment, type PrCommentRole } from '../agent-substrate/pr-comment-meta.js';
-import { changedFiles, commitTitles, type SelfImplementCompletionDisposition } from './seams.js';
+import { changedFiles, commitTitles, type OpenPrOutcome, type SelfImplementCompletionDisposition } from './seams.js';
+import { findUnwiredExports, gitBaseFileReader } from './wiring-check.js';
 import {
   classifyAbandonedRun,
   isAbandonedClassificationOutcome,
@@ -1087,6 +1133,8 @@ export interface SelfImplementSeams {
   commitFinishedChildWork?: (cwd: string, paths: readonly string[], message: string) => { ok: boolean; out: string };
   /** --ground 코드베이스 prepass seam. cwd는 구현 대상 worktree이며 실패는 goal-loop를 막지 않는다. */
   groundGoal?: (goalText: string, deps: { cwd: string }) => Promise<string>;
+  /** E1 GOAL-ELABORATE-ON-ARRIVAL — 착수 구체화 카드 작성·판정 LLM. 미주입이면 카드 없이 진행(`goal-elaboration-skipped`). */
+  elaborateCallLLM?: (args: { prompt: string; systemPrompt?: string }) => Promise<string>;
   /** ③ 구현 — cwd(worktree)에서 코딩 에이전트 구동(P1: 헤드리스 elanous spawn·goal-loop 아밍).
    *  escalateTier(#2) — sol 단일 승급으로 재시도하고 seam 이 그 대상을 honor한다. */
   /** ⚠️ `runId` 는 **필수**(리뷰 should-fix) — 오케스트레이터가 항상 보장하므로 옵셔널로 두면 새 seam
@@ -1156,6 +1204,8 @@ export interface SelfImplementSeams {
   /** Test seam for blocked environment branch persistence; return whether the branch was pushed. */
   /** Test seam — the worktree commit to pin before main sync (default `git rev-parse HEAD`). */
   headCommit?: (cwd: string) => string | undefined;
+  /** Test seam for required evidence command execution; production uses its bounded shell runner. */
+  evidenceCommandRunner?: (command: string, cwd: string) => Pick<ReturnType<typeof spawnSync>, 'status' | 'stdout' | 'stderr' | 'error'>;
   /** `commit` pins the pushed state; without it the worktree HEAD is pushed. */
   preserveBlockedBranch?: (ctx: { cwd: string; branch: string; title: string; commit?: string }) => boolean | Promise<boolean>;
   /** DRAFT-NOT-ARCHIVE — `tools.selfImplement.draftOnStop` 읽기 seam. 생략하면 user-config(실패·부재 = 'always' · 종전). */
@@ -1167,9 +1217,13 @@ export interface SelfImplementSeams {
   /** Persist a full oversized PR body so its bounded PR counterpart can link to it. */
   persistPrBodyArtifact?: (input: { origin: string; body: string; originalChars: number }) => { path: string };
   /** ⑥ PR 생성. labels=생성 시 부착할 GitHub 라벨(G8 auto-review 자기판단 통과 시). */
-  openPr: (opts: { title: string; body: string; head: string; base?: string; draft?: boolean; labels?: string[]; cwd: string }) => Promise<{ url: string; number: number }>;
+  openPr: (opts: { title: string; body: string; head: string; base?: string; draft?: boolean; labels?: string[]; cwd: string; runId?: string }) => Promise<OpenPrOutcome>;
   /** PR 생성 뒤 런의 라운드 대화를 게시한다. 실패는 PR 개설을 되돌리지 않는다. */
   postPrComment?: (opts: { number: number; body: string; cwd: string }) => Promise<void>;
+  /** Read-only body/state confirmation for the failed-run draft preservation marker. */
+  readPrBodyForHarvest?: (opts: { number: number; cwd: string }) => Promise<{ body: string; state: string; isDraft: boolean } | undefined>;
+  /** Update only the confirmed existing PR body; never creates a PR. */
+  updatePrBodyForHarvest?: (opts: { number: number; body: string; cwd: string }) => Promise<void>;
   /** Read and edit the single marked status comment; missing seams fall back to individual comments. */
   findPrComment?: (opts: { number: number; marker: string; cwd: string; comments?: unknown }) => Promise<{ id: number; body: string } | undefined>;
   editPrComment?: (opts: { id: number; body: string; cwd: string }) => Promise<void>;
@@ -2326,6 +2380,14 @@ export interface SelfImplementResult {
   sessionId?: string;
   worktreePath?: string;
   branch?: string;
+  /** SCOPE-AS-DIRECTION: outside-target files the scope guard accepted, each with its kind; rendered as the PR body's «범위 확장». */
+  scopeExpansion?: ScopeExpansion;
+  /** Bounded names measured by the execution-scope guard on a held edit. */
+  outOfScopeEdits?: string[];
+  /** SCOPE-ESCAPE-AS-REFINE: why the held edit stops (deletion · protected path · cap) — the parent stops only on these. */
+  scopeStopReasons?: ScopeStopReason[];
+  nameCapReached?: boolean;
+  outsideCount?: number;
   gate?: SelfImplementGateResult;
   review?: SelfImplementReview;
   rework?: ReviewRework;
@@ -2366,6 +2428,9 @@ export interface SelfImplementResult {
   mergeReason?: string;
   prUrl?: string;
   prNumber?: number;
+  /** REPAIR-BLOCKED-DRAFT-LINK-ORIGINAL: commit-only 수리가 멈춰 새 PR 대신 원 PR 에 이은 수확 가지. */
+  originalPr?: number;
+  salvageRef?: string;
   checkedHeadCommit?: string;
   detail?: string;
 }
@@ -3490,6 +3555,7 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
     const loadLedger = s?.stopAutohealLoadLedger ?? (s?.writeRunLedger ? () => null : undefined);
     const result = await autohealFromStop({ runId: stopEntry.runId, ...(stopEntry.goalId ? { goalId: stopEntry.goalId } : {}), record }, {
       mode,
+      knowhowCandidateDir: join(effectiveInstanceRoot(), 'self-implement', 'knowhow-candidates'),
       ...(s?.stopAutohealActions ? { actions: s.stopAutohealActions } : {}),
       ...(loadLedger ? { loadLedger } : {}),
       ...(s?.writeRunLedger ? { writeLedger: s.writeRunLedger } : {}),
@@ -3764,6 +3830,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       openPr: async (args) => {
         openPrInvoked = true;
         const pr = await opts.seams.openPr(args);
+        if (pr.rebind) debug.log('self-implement.same-cell', 'rebind-result', pr.rebind);
         const number = recordedPrNumber(pr.number);
         if (number !== undefined) capturedPrNumber = number;
         return pr;
@@ -4380,6 +4447,50 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   } finally {
     if (loopRegistered) registerRunLoop('ended');
     const terminalStage = terminalResult?.stage ?? 'crashed';
+    // A blocked draft may be opened on the first failed attempt, before the
+    // normal outcome observer has written its terminal status. Persist the
+    // actual terminal result before exposing harvest-deferred on that PR.
+    const terminalOutcome = terminalResult ? mapStageToRunStatus(terminalStage) : undefined;
+    if (terminalOutcome?.runStatus === 'failed'
+      && loadRunLedger(runId)?.filter((entry) => entry.event === 'run-status').at(-1)?.data.runStatus !== 'failed') {
+      observeOuter('run-status', {
+        stage: terminalStage, node: terminalResult?.node ?? null, ...terminalOutcome,
+        ...(terminalResult?.reviewReflectRejectedCount !== undefined
+          ? { reviewReflectRejectedCount: terminalResult.reviewReflectRejectedCount }
+          : {}),
+      }, { level: 'warn' });
+    }
+    try {
+      const runStatus = terminalOutcome?.runStatus;
+      const prNumber = recordedPrNumber(terminalResult?.prNumber) ?? capturedPrNumber;
+      // openPr is required on every seam (including production); it cannot
+      // distinguish test PRs from real ones. The production adapter explicitly
+      // supplies both body operations. A test replacing openPr without both
+      // body operations must fail closed instead of touching a real PR.
+      const readPrBody = opts.seams.readPrBodyForHarvest;
+      const updatePrBody = opts.seams.updatePrBodyForHarvest;
+      // The terminal observer must have persisted this run's failure before a
+      // draft can advertise harvest deferral. Even an injected writer must
+      // leave a matching record in the canonical ledger before mutation.
+      const lastPersistedStatus = loadRunLedger(runId)?.filter((entry) => entry.event === 'run-status').at(-1)?.data.runStatus;
+      const persistedFailure = runStatus === 'failed' && lastPersistedStatus === 'failed';
+      if (persistedFailure && prNumber !== undefined && readPrBody && updatePrBody) {
+        const existing = await readPrBody({ number: prNumber, cwd: worktreePath ?? process.cwd() });
+        if (existing?.state === 'OPEN' && existing.isDraft === true) {
+          const markedBody = markHarvestDeferredBody({ runStatus, prNumber, body: existing.body });
+          if (markedBody !== undefined && markedBody !== existing.body) {
+            await updatePrBody({ number: prNumber, body: markedBody, cwd: worktreePath ?? process.cwd() });
+            observeOuter('harvest-deferred', { runStatus, prNumber, marker: HARVEST_DEFERRED_MARKER });
+          }
+        } else {
+          observeOuter('harvest-deferred-skipped', { runStatus, prNumber, reason: 'existing-draft-not-confirmed' }, { level: 'warn' });
+        }
+      } else {
+        observeOuter('harvest-deferred-skipped', { runStatus: runStatus ?? null, prNumber: prNumber ?? null, reason: 'status-pr-body-seam-unavailable' }, { level: 'warn' });
+      }
+    } catch (error) {
+      logRunAwareFailSoft(runId, 'harvest-deferred-failed', { error: safeErrorDescription(error) });
+    }
     try {
       const mappedStatus = mapStageToRunStatus(terminalStage)?.runStatus;
       const reworkCapStop = terminalResult?.stage === 'pr-opened' && (
@@ -4727,7 +4838,7 @@ export function observeRunOutcome(
 type RollupPrNumber = number | 'none' | 'unknown';
 
 function recordedPrNumber(value: unknown): number | undefined {
-  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
 
 function rollupPrNumber(
@@ -4855,7 +4966,7 @@ async function runSelfImplementInner(
     const { graphVersionHash } = await import('./graph-yaml.js');
     const { applyGraphOverlays } = await import('./graph-overlay-yaml.js');
     const { createGraphVariant } = await import('./graph-variant.js');
-    const { runLedgerPath } = await import('./run-ledger.js');
+    const { saveRunGraphVariant, loadRunGraphVariant } = await import('./run-ledger.js');
     const { stringify } = await import('yaml');
     const baseSpec = GRAPH_SPECS[graphTemplate.graphId];
     const variantRunId = identity?.runId ?? opts.runId;
@@ -4867,16 +4978,16 @@ async function runSelfImplementInner(
       : undefined;
     if (launch && !launch.ok) throw new Error(`graph variant rejected: ${JSON.stringify(launch.rejections)}`);
     const sourceSpec = launch?.ok ? launch.template : baseSpec;
-    const variant = createGraphVariant({ template: sourceSpec, goal: `g_${variantRunId.replace(/[^a-z0-9_-]/gi, '_')}`, plan: opts.graphVariantPlan });
+    // ⭐ 최초 변형 선택 — 골 종류(graphGoalType)·대상 경로 수(declaredPremiseScopePaths) 두 입력만으로
+    //   결정론적으로 id·선택 이유를 유도해 검증 결과에 싣는다(종류를 못 읽었으면 지어내지 않는다).
+    const variant = createGraphVariant({ template: sourceSpec, goal: `g_${variantRunId.replace(/[^a-z0-9_-]/gi, '_')}`, plan: opts.graphVariantPlan,
+      ...(graphGoalType === undefined ? {} : { goalAnalysis: { goalType: graphGoalType, targetPathCount: declaredPremiseScopePaths(opts.feature).length } }) });
     if (!variant.ok) throw new Error(`graph variant rejected: ${JSON.stringify(variant.rejections)}`);
     variantSpec = variant.template;
     graphTemplate = { ...specToTemplate(variantSpec), version: graphVersionHash(variantSpec) };
-    const { runLedgerDir } = await import('./run-ledger.js');
-    const graphFile = `${runLedgerPath(variantRunId)}.graph.yaml`;
-    mkdirSync(runLedgerDir(), { recursive: true });
-    const { writeFileSync } = await import('node:fs');
-    writeFileSync(graphFile, stringify({
+    const graphFile = saveRunGraphVariant(variantRunId, stringify({
       graph_id: variantSpec.graphId, version: variantSpec.version,
+      ...(variant.selection === undefined ? {} : { variant_id: variant.selection.variantId, reason: variant.selection.reason }),
       entry_node: variantSpec.entryNode, terminal_nodes: variantSpec.terminalNodes,
       ...(variantSpec.journeyStages ? { journey_stages: variantSpec.journeyStages } : {}),
       ...(variantSpec.runContract ? { run_contract: variantSpec.runContract } : {}),
@@ -4886,6 +4997,9 @@ async function runSelfImplementInner(
         ...(n.progress ? { progress: n.progress } : {}), ...(n.phases ? { phases: n.phases } : {}),
         ...(n.terminalStages ? { terminal_stages: n.terminalStages } : {}),
         ...(n.fanOut ? { fan_out: n.fanOut } : {}), ...(n.contract ? { contract: n.contract } : {}),
+        ...(n.call ? { call: n.call } : {}),
+        ...(n.callEntry ? { call_entry: n.callEntry } : {}),
+        ...(n.budget ? { budget: { inner_steps: n.budget.innerSteps } } : {}),
         ...(n.skipWhen ? { skip_when: n.skipWhen } : {}),
       })),
       edges: variantSpec.edges.map(e => ({
@@ -4894,9 +5008,17 @@ async function runSelfImplementInner(
         ...(e.observed === undefined ? {} : { observed: e.observed }),
         ...(e.when ? { when: e.when } : {}),
       })),
-    }), { flag: 'wx' });
+    }));
+    // ⭐ 저장·diff — 방금 원장 옆에 쓴 선택(id·이유)을 다시 읽어 «같은지» 확인한다(다르면 이 런의 그래프 신원이 거짓).
+    if (variant.selection !== undefined) {
+      const persisted = loadRunGraphVariant(variantRunId);
+      if (persisted === null || persisted.variantId !== variant.selection.variantId || persisted.reason !== variant.selection.reason) {
+        throw new Error(`graph variant rejected: persisted selection mismatch: ${JSON.stringify(persisted)}`);
+      }
+    }
     observe('graph-variant-applied', { graphId: variant.template.graphId, overlayId: variant.overlay.overlayId,
-      graphFile, patches: variant.patches });
+      graphFile, patches: variant.patches,
+      ...(variant.selection === undefined ? {} : { variantId: variant.selection.variantId, variantReason: variant.selection.reason }) });
   }
   /** 단계 이름 → 그 템플릿의 노드 이름. */
   const node = (stage: PipelineNodeId): PipelineNodeId => nodeNameForStage(stage, graphTemplate) as PipelineNodeId;
@@ -5018,6 +5140,8 @@ async function runSelfImplementInner(
   observe('start', {
     feature: boundedFeature.text, featureTruncated: boundedFeature.truncated, featureOriginalChars: boundedFeature.originalChars,
     branch, base: opts.base ?? null, draft: opts.draft ?? true,
+    // OPT #25551: 런 모드가 원장에 없었다 — PR 개설 의도 ⊕ commit-only 수리의 원 PR 번호(합성 base pr-<N>).
+    openPr: opts.completion === undefined ? null : opts.completion !== 'worktree-only', repairCommitOnly: syntheticRepairBasePr(opts.base) ?? null,
     willFork: !!(opts.parentSessionId && s.forkSession), parentSessionId: opts.parentSessionId ?? null,
     nestDepth: nestInfo().depth, goalSource, goalFile: opts.goalFile === undefined ? null : resolve(launchCwd, opts.goalFile),
     targetRoot: gitRootOf(launchCwd) ?? launchCwd, ...originObservationFields(),
@@ -5075,6 +5199,14 @@ async function runSelfImplementInner(
     ...goalContext,
   }), T.worktree, 'worktree');
   onWorktreeCreated(wt.path);
+  // Capture the child worktree's HEAD at creation. `wt.invokedHead` names the
+  // caller checkout and may differ after base selection or PR-source checkout.
+  const terminalLaunchHeadRead = runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 });
+  const terminalLaunchHeadCandidate = terminalLaunchHeadRead.status === 0 ? terminalLaunchHeadRead.stdout.trim() : '';
+  const terminalLaunchHead = /^[0-9a-f]{40,64}$/i.test(terminalLaunchHeadCandidate) ? terminalLaunchHeadCandidate : undefined;
+  const terminalLaunchWork = detectUncommittedWork(wt.path);
+  const terminalLaunchDirtyPaths = terminalLaunchWork.status === 'unavailable' ? undefined
+    : new Set([...terminalLaunchWork.trackedChanges, ...terminalLaunchWork.untrackedFiles]);
   // ⭐ 제1원칙 — **어디서 갈랐나**를 관측에 남긴다. 이것이 없어서 2026-07-29 에 하니스 런 둘이
   //   `main` 위에서 돌았고(호출자가 브랜치 워크트리에서 발사했는데도) 산출 diff 를 눈으로 봐야 알았다.
   //   ⚠️ `branch` 는 **새로 만든 브랜치 이름**이라 그 질문에 답하지 않는다.
@@ -5088,6 +5220,8 @@ async function runSelfImplementInner(
   observe('worktree', {
     path: wt.path,
     branch: wt.branch,
+    terminalLaunchHead: terminalLaunchHead ?? null,
+    terminalLaunchDirtyPaths: terminalLaunchDirtyPaths ? [...terminalLaunchDirtyPaths] : null,
     // ⭐ 우리가 **무엇을 요청했는지는 이미 안다** — 시임 반환에서 되읽지 않는다.
     //    커스텀 시임이 관측 필드를 생략하면 명시/생략이 둘 다 null 이 되어 구분이 사라진다(리뷰 must-fix).
     requestedBase,
@@ -5259,6 +5393,14 @@ async function runSelfImplementInner(
   if (knowhow.text) round0Feature = `${knowhow.text}\n\n${round0Feature}`;
   observe('knowhow-pack', { ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0 });
 
+  // E1 착수 구체화(RFC-progressive-goal-elaboration §2 E1 · §7 간선 ①) — 고정 층(KPI·판정 신호)은 그대로, 카드만 덧붙인다.
+  const elaboration = await (await import('./goal-elaborate.js')).runArrivalElaboration({ goal: opts.feature, prompt: round0Feature, cwd: wt.path, callLLM: s.elaborateCallLLM, observe });
+  round0Feature = elaboration.prompt;
+  if (elaboration.parked) {
+    progress('parked', '착수 구체화 카드가 골 고정 층과 어긋남(다시 쓰기 뒤에도) — 사람 판단 대기');
+    return { ok: false, stage: 'parked', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch, detail: elaboration.detail };
+  }
+
   const maxRework = Math.max(0, opts.maxReworkRounds ?? 2);
   const selfImplementConfig = (await import('../user-config.js')).getUserConfig().tools.selfImplement;
   const shadowStop = opts.reworkBudgetShadowStop ?? selfImplementConfig.reworkBudget.shadowStop;
@@ -5290,6 +5432,8 @@ async function runSelfImplementInner(
   let gate!: SelfImplementGateResult;
   /** GATE-ENV-RETRY: 재시도 뒤에도 남은 환경 결손의 종류. 정의되면 이 라운드의 gate 실패는 «수확 대기»로 끝난다. */
   let gateEnvDeficitKind: GateEnvDeficitKind | undefined;
+  /** SCOPE-AS-DIRECTION: outside-target files accepted by the scope guard (latest round); rendered in the PR body. */
+  let scopeExpansion: ScopeExpansion | undefined;
   let review: SelfImplementReview | undefined;
   let reviewedHeadCommit: string | undefined;
   /** Review-budget leftovers and the body that carried them, so a later merge drafts from the same text. */
@@ -5609,9 +5753,17 @@ async function runSelfImplementInner(
     };
   }
   let round = 0;
+  // A timeout is evidence about this command, not an invitation to spend the
+  // next rework round on the identical oversized check.
+  const runBudgetedEvidenceChecks = createRequiredEvidenceBudget({ run: s.evidenceCommandRunner });
   // A goal-only retry spends its one allowance for this run even if a later
   // gate/review round removes the target diff and reaches the same disposition.
   let goalOnlyReworkUsed = false;
+  // E3 GOAL-REFINE-FROM-FIRST-IMPL — 첫 라운드 뒤 골 v2(재그라운딩). 둘째 라운드부터 프롬프트의 골은 roundGoal 이다.
+  //   방향·KPI 줄은 불변(goal-refine.ts 가 강제) · 되돌이는 런당 GOAL_REFINE_MAX_VISITS 번.
+  let roundGoal = opts.feature;
+  let goalRefineVisits = 0;
+  let goalRefinement: import('./goal-refine.js').GoalRefinement | undefined;
   // PR이 열리기 전에 프로세스가 죽으면 PR 자체가 없으므로 잃을 대화도 없다. 따라서 파일로 영속화하지 않는다.
   const prCommentBuffer: string[] = [];
   // GitHub PR comment bodies are bounded; retain the RFC header and disclose omitted source rather than losing the whole record.
@@ -5730,10 +5882,12 @@ async function runSelfImplementInner(
   };
   let blockedDraftNoChanges = false;
   let blockedDraftPrFailure: string | undefined;
+  let repairLink: { originalPr: number; salvageRef: string } | undefined;
   const reviewBlockedResult = (pr: { url: string; number: number } | undefined) => ({
     stage: blockedDraftNoChanges && podReviewBlockedDraft ? 'no-changes' as const : podReviewBlockedDraft && !pr ? 'aborted' as const : 'review-blocked' as const,
     mustFix: [...(review?.mustFix ?? [])],
     ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}),
+    ...(repairLink ?? {}),
   });
   const preserveBlockedArtifacts = async ({ stage, reason, verdict, gate: preservedGate, typecheck, decomposition, childSummary, reasonTruncated, failureKind, terminalStatus, salvageStatusExpected }: { stage: 'review-blocked' | 'gate-failed' | 'aborted'; reason: string; verdict?: ReworkBudgetVerdict; gate?: SelfImplementGateResult; typecheck?: { passed: boolean; log?: string }; decomposition?: TerminalDecomposition; childSummary?: string; reasonTruncated?: boolean; failureKind?: ReturnType<typeof classifyReviewProviderFailure> | null; terminalStatus?: ImplementTerminalStatus; salvageStatusExpected: boolean }): Promise<{ url: string; number: number } | undefined> => {
     let childSummaryArtifact: ChildSummaryArtifactRef | undefined;
@@ -5940,6 +6094,47 @@ async function runSelfImplementInner(
       progress(stage, '보존할 변경이 없어 draft PR을 열지 않음');
       return undefined;
     }
+    // REPAIR-BLOCKED-DRAFT-LINK-ORIGINAL: 합성 base pr-<N>(commit-only 수리)은 origin 에 없다 — 새 draft 대신 수확 가지를 원 PR #N 에 잇는다.
+    const blockedTarget = blockedDraftTargetFor(opts.base);
+    if (blockedTarget.action === 'link-original') {
+      const salvageRef = salvageBranchForRun(runId, wt.branch);
+      let salvageSha: string | undefined;
+      let pushError: string | undefined;
+      try {
+        if (s.preserveBlockedBranch) {
+          if (!await s.preserveBlockedBranch({ cwd: wt.path, branch: salvageRef, title: prTitle(opts.feature, opts.goalFile) })) throw new Error('수확 가지 push가 성공하지 않았음');
+        } else {
+          const commit = commitWorktree(wt.path, prTitle(opts.feature, opts.goalFile));
+          if (!commit.ok && !/nothing to commit/.test(commit.out)) throw new Error(`로컬 커밋 실패: ${commit.out}`);
+          const push = runGitCommand(wt.path, ['push', 'origin', `HEAD:refs/heads/${salvageRef}`]);
+          if (push.status !== 0) throw new Error(push.stderr || push.stdout || 'git push failed');
+        }
+        const head = existsSync(wt.path) ? runGitCommand(wt.path, ['rev-parse', 'HEAD']) : undefined;
+        if (head?.status === 0) salvageSha = head.stdout.trim();
+      } catch (error) {
+        pushError = safeErrorDescription(error);
+      }
+      let commentError: string | undefined;
+      if (pushError === undefined) {
+        try {
+          if (!s.postPrComment) throw new Error('postPrComment seam unavailable');
+          await s.postPrComment({ number: blockedTarget.originalPr, body: repairSalvageLinkComment({ salvageRef, ...(salvageSha ? { sha: salvageSha } : {}), runId, stage }), cwd: wt.path });
+        } catch (error) {
+          commentError = safeErrorDescription(error);
+        }
+      }
+      if (pushError === undefined) repairLink = { originalPr: blockedTarget.originalPr, salvageRef };
+      observe('rework-blocked-draft-pr', {
+        ...observation, skipped: 'repair-link-original', originalPr: blockedTarget.originalPr, salvageRef,
+        ...(salvageSha ? { salvageSha } : {}), pushed: pushError === undefined, ...(pushError ? { pushError } : {}),
+        commentPosted: pushError === undefined && commentError === undefined, ...(commentError ? { commentError } : {}),
+      }, pushError || commentError ? { level: 'warn' } : undefined);
+      blockedDraftPrFailure = pushError
+        ? `수리 산출물 수확 가지 push 실패(원 PR #${blockedTarget.originalPr} · 새 PR 안 엶): ${pushError}; worktree: ${wt.path}`
+        : `수리 산출물을 기존 PR #${blockedTarget.originalPr} 에 연결: salvage ${salvageRef}${commentError ? ` (코멘트 실패: ${commentError})` : ''}`;
+      progress('aborted', blockedDraftPrFailure);
+      return undefined;
+    }
     // DRAFT-NOT-ARCHIVE (RFC R1): harvestable 멈춤은 draft PR 대신 수확 가지 ⊕ 런 원장(사유·다음 수).
     // ⛔ Pod review-blocked 는 결과 stage 가 PR 유무로 갈리므로 이 조각에서는 건드리지 않는다.
     const draftOnStopMode = readDraftOnStopMode();
@@ -6051,6 +6246,7 @@ async function runSelfImplementInner(
     try {
       pr = await withStepTimeout(s.openPr({
         title: prTitle(opts.feature, opts.goalFile),
+        runId,
         body: assembled.body,
         head: wt.branch,
         ...(opts.base ? { base: opts.base } : {}),
@@ -6097,6 +6293,9 @@ async function runSelfImplementInner(
         : `중단 산출물의 draft PR 생성 실패(worktree·branch 보존 · 판정 본문 보존 실패: ${artifactError ?? 'unknown error'})`);
       return undefined;
     }
+    // The production draft sweep resolves run ownership from pr-opened, not
+    // from the blocked-draft diagnostic event. Bind this PR to the same run.
+    observe('pr-opened', { url: pr.url, number: pr.number, branch: wt.branch, draft: true });
     observe('rework-blocked-draft-pr', {
       ...observation,
       url: pr.url,
@@ -6199,7 +6398,7 @@ async function runSelfImplementInner(
     // and pushes this worktree after the note is written and before creating the PR.
     addNextMdReleaseNote(wt.path, releaseNote);
     const preparedPrBody = preparePrBody(
-      `${prBody(opts.feature, impl.summary, gate.log, review, reviewIntent, undefined, harvestedForPr(), opts.goalFile, lastPlanRevision, releaseNote)}${followUpMustFix}`,
+      `${prBody(roundGoal, impl.summary, gate.log, review, reviewIntent, undefined, harvestedForPr(), opts.goalFile, lastPlanRevision, releaseNote)}${renderScopeExpansionSection(scopeExpansion)}${goalRefinement ? `\n\n${(await import('./goal-refine.js')).renderGoalChangeSection(goalRefinement)}` : ''}${followUpMustFix}`,
       s.persistPrBodyArtifact,
       'self-implement-review-budget-pr',
       followUpMustFix,
@@ -6207,6 +6406,7 @@ async function runSelfImplementInner(
     preparedReviewBudgetPrBody = preparedPrBody.body;
     const pr = await withStepTimeout(s.openPr({
       title: prTitle(opts.feature, opts.goalFile),
+      runId,
       body: preparedPrBody.body,
       head: wt.branch,
       ...(opts.base ? { base: opts.base } : {}),
@@ -6365,7 +6565,7 @@ async function runSelfImplementInner(
         const predictionAccuracyBefore = supervisorDecisionHistory.length
           ? judgePredictionAccuracy(supervisorDecisionHistory)
           : undefined;
-        diagnosis = await withStepTimeout(s.diagnose({ runId, note: reworkJudgeNote, kind: reworkKind, round, cwd: wt.path, goal: opts.feature, history: priorHistory, supervisorDecisionHistory, ...(predictionAccuracyBefore ? { judgePredictionAccuracy: predictionAccuracyBefore } : {}), effectiveMax, priorRuns, reviewFindingTelemetry: reviewFindingTelemetrySnapshot, ...(diagnosisRefutations ? { refutations: diagnosisRefutations.refutations, refutationRound: diagnosisRefutations.round } : {}), purpose: 'budget' }), T.review, 'review');
+        diagnosis = await withStepTimeout(s.diagnose({ runId, note: reworkJudgeNote, kind: reworkKind, round, cwd: wt.path, goal: roundGoal, history: priorHistory, supervisorDecisionHistory, ...(predictionAccuracyBefore ? { judgePredictionAccuracy: predictionAccuracyBefore } : {}), effectiveMax, priorRuns, reviewFindingTelemetry: reviewFindingTelemetrySnapshot, ...(diagnosisRefutations ? { refutations: diagnosisRefutations.refutations, refutationRound: diagnosisRefutations.round } : {}), purpose: 'budget' }), T.review, 'review');
         const diagnosedDecision = parseReworkBudgetDecision(diagnosis);
         if (diagnosedDecision?.verdict === 'CONTRACT-CONFLICT') lastSupervisorVerdict = diagnosedDecision.verdict;
         let parsedDecision = diagnosedDecision;
@@ -6809,7 +7009,7 @@ async function runSelfImplementInner(
     if (escalationEligible && s.diagnose) {
       try {
         escalationJudgement = await withStepTimeout(s.diagnose({
-          runId, note: reworkNote, kind: reworkKind, round, cwd: wt.path, goal: opts.feature,
+          runId, note: reworkNote, kind: reworkKind, round, cwd: wt.path, goal: roundGoal,
           history: reworkHistory.slice(0, -1), supervisorDecisionHistory, effectiveMax,
           purpose: 'escalation-triage',
         }), T.review, 'review');
@@ -6822,8 +7022,24 @@ async function runSelfImplementInner(
         }, { level: 'warn' });
       }
     }
+    // 라운드 «번호»가 아니라 «첫 gate·리뷰 지적을 받은 뒤 첫 rework 진입»에서 한 번 — goal-only-rework·증거 되먹임이
+    //   번호를 당겨도(round = retryRound/nextRound) 한 번 돈다(리뷰 r1 should-fix 6).
+    if (round > 0 && goalRefineVisits === 0 && reworkNote.trim().length > 0) {
+      goalRefineVisits++;
+      // ta-journey author-dialogue 되돌이(judge findings → author → deliver v2) — 노트 LLM 은 E1 과 같은 저작 래퍼를 쓴다.
+      const firstRound = roundSummaryEntries.at(-1);
+      const refined = await (await import('./goal-refine.js')).runFirstRoundRefine({
+        goal: opts.feature, round, visit: goalRefineVisits, callLLM: s.elaborateCallLLM, observe,
+        // SCOPE-ESCAPE-AS-REFINE — accepted out-of-scope edits are the «new scope» the first implementation found.
+        evidence: { implSummary: firstRound?.tried, findings: reworkNote, changedFiles: firstRound?.filesTouched,
+          ...(scopeExpansion?.files.length ? { newScope: scopeExpansion.files.map((file) => file.path) } : {}) },
+      });
+      roundGoal = refined.goal;
+      // PR «골 변경» 절 — 유지(kept · no-provider 포함)여도 «시도 · v1 유지 · 사유» 한 줄을 싣는다(리뷰 r2).
+      goalRefinement = refined.refinement;
+    }
     const reworkFeature = round === 0 ? ''
-      : buildReworkFeature(opts.feature, round, effectiveMax, reworkPromptNote, stripReworkBudgetHeaders(diagnosis), appliedLastRound, refutableFindings, pendingPlanRevision, reworkKind, buildRefutationGuidance(), escalationJudgement);
+      : buildReworkFeature(roundGoal, round, effectiveMax, reworkPromptNote, stripReworkBudgetHeaders(diagnosis), appliedLastRound, refutableFindings, pendingPlanRevision, reworkKind, buildRefutationGuidance(), escalationJudgement);
     const card = round === 0 ? '' : renderRoundSummaryCard(roundSummaryEntries);
     const feature = round === 0 ? round0Feature : reworkFeature + (card ? `\n\n${card}` : '');
     if (card) {
@@ -7046,6 +7262,45 @@ async function runSelfImplementInner(
         }
       }
     }
+    // The child can report changed=false after committing its edits. Compare
+    // against the worktree HEAD captured at creation, not the caller's HEAD or
+    // origin/main: a PR source already had a diff before the child ran.
+    if (!impl.ok && impl.completionDisposition === 'completed-without-changes'
+      && impl.terminalStatus?.reached === true && impl.terminalStatus.timedOut === false
+      && !hasCurrentProviderError() && !hasCurrentCredentialFailure()) {
+      const committed = terminalLaunchHead
+        ? runGitCommand(wt.path, ['diff', '--name-only', '-z', terminalLaunchHead, 'HEAD'], { encoding: 'utf8', timeout: 10_000 })
+        : undefined;
+      const pending = detectUncommittedWork(wt.path);
+      const observedFiles = committed?.status === 0 && pending.status !== 'unavailable'
+        ? [...new Set([
+          ...committed.stdout.split('\0').filter(Boolean),
+          ...pending.trackedChanges, ...pending.untrackedFiles,
+        ])]
+        : [];
+      if (!terminalLaunchHead || terminalLaunchDirtyPaths === undefined || committed?.status !== 0 || pending.status === 'unavailable') {
+        observe('terminal-change-evidence', { round, status: 'unmeasured',
+          reason: !terminalLaunchHead ? 'launch-head-unavailable' : terminalLaunchDirtyPaths === undefined
+            ? 'launch-status-unavailable' : committed?.status !== 0 ? 'git-diff-unavailable' : 'git-status-unavailable' }, { level: 'warn' });
+      }
+      // A PR-source worktree may be dirty before this child starts. A path
+      // already dirty at launch cannot prove this child's edits from names
+      // alone, even if the child later commits it. Leave that path unmeasured.
+      const implementationFiles = terminalLaunchDirtyPaths === undefined ? [] : observedFiles.filter(path =>
+        !terminalLaunchDirtyPaths.has(path) && !harnessSeededPaths.includes(path) && !isHarnessTempArtifact(path));
+      const preexistingDirtyPaths = terminalLaunchDirtyPaths === undefined ? [] : observedFiles.filter(path =>
+        terminalLaunchDirtyPaths.has(path) && !harnessSeededPaths.includes(path) && !isHarnessTempArtifact(path));
+      if (preexistingDirtyPaths.length > 0) observe('terminal-change-evidence', {
+        round, status: 'unmeasured', reason: 'preexisting-dirty-path', paths: preexistingDirtyPaths,
+      }, { level: 'warn' });
+      if (implementationFiles.length > 0) {
+        observe('terminal-change-reconciled', {
+          round, source: 'post-launch-git-diff', launchHead: terminalLaunchHead, childDisposition: impl.completionDisposition,
+          paths: implementationFiles, pathCount: implementationFiles.length,
+        });
+        impl = { ...impl, ok: true, completionDisposition: undefined };
+      }
+    }
     // A finished child can leave edits without a commit. Measure them before any
     // diff/no-changes classification, and commit only paths declared in the goal.
     finishedChildCommitMissing = false;
@@ -7075,12 +7330,12 @@ async function runSelfImplementInner(
         const declared = goalDocument === undefined ? undefined : declaredPathsFromGoalDocumentText(goalDocument);
         const targets = declared?.readable
           ? declared.paths
-          : inferHotPaths(targetScopedGoalText(opts.feature));
+          : inferHotPaths(targetScopedGoalText(roundGoal));
         const eligible = [...new Set([...work.trackedChanges, ...work.untrackedFiles])]
           .filter((path) => !harnessSeededPaths.includes(path)
             && targets.some((target) => changedFileIsInsideDeclaredTarget(path, target)));
         if (eligible.length) {
-          inspectStaleReverts(revertGuardTargetPaths(opts.feature, goalDocument));
+          inspectStaleReverts(revertGuardTargetPaths(roundGoal, goalDocument)); // E3 — refine 뒤 v2 «대상 경로»
           const message = `self-implement: ${prTitle(opts.feature, opts.goalFile)}`;
           let outcome: { ok: boolean; out: string };
           try {
@@ -7148,9 +7403,16 @@ async function runSelfImplementInner(
     const evidenceText = diffEvidence ? `${childEvidenceSource}\n${diffEvidence}` : childEvidenceSource;
     evidenceSource = diffEvidence ? 'diff-added-lines' : harvested ? 'harvested' : 'summary-tail';
     offDiffEvidence = parseOffDiffEvidence(evidenceText);
-    const requiredEvidence = requiredEvidenceFromGoal(opts.feature);
-    const limitationCount = authorLimitationCountFromGoal(opts.feature);
-    const evidenceChecks = runRequiredEvidenceChecks(opts.feature, wt.path, runId);
+    // E3 — refine 뒤 라운드는 «현재 골»(v2)로 증거를 센다(REQUIRED EVIDENCE 절은 고정 칸이라 v1 과 같다).
+    const requiredEvidence = requiredEvidenceFromGoal(roundGoal);
+    const limitationCount = authorLimitationCountFromGoal(roundGoal);
+    const evidenceHead = resolveEvidenceHeadCommit(s.headCommit?.(wt.path), () =>
+      runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 }).stdout.trim());
+    if (!evidenceHead) {
+      try { debug.log('self-implement.evidence', 'command-budget-head-unresolved', { runId, round, cwd: wt.path }); }
+      catch { /* observation is fail-soft */ }
+    }
+    const evidenceChecks = runBudgetedEvidenceChecks(roundGoal, wt.path, runId, evidenceHead);
     const tagCoverage = coverRequiredEvidence(requiredEvidence, offDiffEvidence.items);
     // EVIDENCE-WIRING-EXEMPT — a requirement whose own `|| bun test …` check passed is covered by what the harness measured.
     const settledByCheck = settleUncoveredEvidence(tagCoverage.uncovered, { checks: evidenceChecks, required: requiredEvidence });
@@ -7244,6 +7506,7 @@ async function runSelfImplementInner(
     // Unknown declaration or changed files cannot justify an invented choice.
     let gateRouteFiles: readonly string[] | undefined;
     try { gateRouteFiles = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { gateRouteFiles = undefined; }
+    scopeExpansion = undefined;
     if (opts.goalFile) {
       let goalDocument: string | undefined;
       try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { /* unknown scope */ }
@@ -7257,20 +7520,24 @@ async function runSelfImplementInner(
         observe('execution-scope-undeclared', { outsideCount: scope.outsideCount });
         progress('implementing', `⚠️ 대상 경로를 하나도 못 읽었다 — 범위 밖 ${scope.outsideCount}개를 묻지 않고 게이트로 간다`);
       } else if (scope.status === 'known' && scope.outsideCount !== null && scope.outsideCount > 0) {
-        const impact = scope.outsideNames.some(file => {
+        // SCOPE-AS-DIRECTION — target paths are the starting point: outside edits are accepted by default and named for the
+        // reviewer. Only a deletion, a protected path, or more than SCOPE_EXPANSION_CAP outside files stops for the owner.
+        const deleted = scope.outsideNames.filter(file => {
           if (existsSync(join(wt.path, file))) return false;
           const tracked = runGitCommand(wt.path, ['ls-files', '--error-unmatch', '--', file], { encoding: 'utf8', timeout: 20_000 });
           return tracked.status === 0;
-        }) ? 'critical' : 'high';
+        });
+        const impact = deleted.length > 0 ? 'critical' : 'high';
         const declaredPaths = declaredPathsFromGoalDocumentText(goalDocument!).paths;
-        const { adjacent, other } = classifyOutOfScope(scope.outsideNames, declaredPaths);
-        // Only edits next to a declared file, none of them a deletion: the gate judges them — nobody has to answer first.
-        const adjacentOnly = impact !== 'critical' && !scope.nameCapReached && other.length === 0 && adjacent.length === scope.outsideCount;
-        if (adjacentOnly) {
-          observe('execution-scope-adjacent-accepted', { outsideCount: scope.outsideCount, adjacent });
-          progress('implementing', `범위 밖 인접 편집 ${adjacent.length}개(대상과 같은 폴더) — 묻지 않고 게이트로 간다: ${adjacent.join(' · ')}`);
+        const decision = decideScopeExpansion({ outsideFiles: scope.outsideNames, declaredPaths, deleted, nameCapReached: scope.nameCapReached,
+          readFile: file => { try { return readFileSync(join(wt.path, file), 'utf8'); } catch { return undefined; } } });
+        if (decision.accept) {
+          scopeExpansion = decision.expansion;
+          observe('execution-scope-accepted', { outsideCount: scope.outsideCount, count: decision.expansion.count, cap: SCOPE_EXPANSION_CAP,
+            files: decision.expansion.files, round });
+          progress('implementing', `범위 확장 ${decision.expansion.count}개 수용 — 대상 경로는 출발점, PR 본문 «범위 확장»에서 리뷰가 판단한다: ${decision.expansion.files.map(file => `${file.path}(${file.kind})`).join(' · ')}`);
         }
-        const result: ExecutionClarificationResult = adjacentOnly ? { choice: 'Expand scope', by: 'assumed' } : await (s.askExecutionClarification ?? askAtExecution)({
+        const result: ExecutionClarificationResult = decision.accept ? { choice: 'Expand scope', by: 'assumed' } : await (s.askExecutionClarification ?? askAtExecution)({
           id: 'execution_scope', decision: 'Changing files outside the authored target paths',
           prompt: 'Implementation changed files outside the authored target paths. Keep the original scope or expand it?',
           whyNow: 'Continuing to gate or publish these edits would expand the requested scope.',
@@ -7280,11 +7547,18 @@ async function runSelfImplementInner(
             { label: 'Expand scope', description: 'Accept the changed files outside the target paths.' },
           ],
         }, { runId, outsideFiles: scope.outsideNames, outsideCount: scope.outsideCount, declaredPaths }, { writeRunLedger: s.writeRunLedger });
+        if (!decision.accept && !('parked' in result) && !('deferred' in result) && result.choice === 'Expand scope') scopeExpansion = decision.expansion;
         if ('parked' in result || 'deferred' in result || result.choice !== 'Expand scope') {
           finalizeSupervisorDeliveries('execution-scope-not-approved');
-          observe('execution-scope-held', { outsideCount: scope.outsideCount, disposition: 'parked' in result ? 'parked' : 'in-scope-only' });
+          const outOfScopeEdits = [...scope.outsideNames];
+          observe('execution-scope-held', { outOfScopeEdits, nameCapReached: scope.nameCapReached,
+            outsideCount: scope.outsideCount, worktreePath: wt.path, branch: wt.branch,
+            disposition: 'parked' in result ? 'parked' : 'in-scope-only',
+            ...(!decision.accept ? { stopReasons: decision.reasons, deleted: decision.deleted, protectedPaths: decision.protectedPaths, cap: SCOPE_EXPANSION_CAP } : {}),
+            files: decision.expansion.files });
           if ('parked' in result) progress('parked', `critical 질문 ${result.questionId} 미응답 — 이 런만 대기`);
           return { ok: false, stage: 'parked' in result ? 'parked' : 'soft-stopped', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch,
+            outOfScopeEdits, ...(!decision.accept ? { scopeStopReasons: decision.reasons } : {}), nameCapReached: scope.nameCapReached, outsideCount: scope.outsideCount,
             detail: 'parked' in result ? `critical-unanswered: ${result.questionId}` : 'Out-of-scope edits held in the worktree; gate and publication skipped.' };
         }
       }
@@ -7581,6 +7855,33 @@ async function runSelfImplementInner(
         if (untracked.status === 0) untrackedFiles = untracked.stdout.split(/\r?\n/).filter(Boolean);
       } catch { /* change discovery must not stop review */ }
     }
+    // Gate has passed. Measure newly exported runtime values before review, without
+    // turning a static-analysis guess into a rework verdict during the first rollout.
+    const wiringFiles = [...new Set([...(runFacts.changedFiles ?? []), ...(gateRouteFiles ?? []), ...untrackedFiles])];
+    if (wiringFiles.some((file) => /^(?:src|scripts|apps\/pwa\/src)\/.*\.tsx?$/.test(file))) {
+      const wiringBase = wt.resolvedBase;
+      const wiring = wiringBase && /^[0-9a-f]{40}$/i.test(wiringBase)
+        ? findUnwiredExports({
+            cwd: wt.path,
+            changedFiles: wiringFiles,
+            // Timeouts and git errors throw → recorded as `failure`, never as "absent at base".
+            readBaseFile: gitBaseFileReader(
+              (args) => runGitCommand(wt.path, args, { encoding: 'utf8', timeout: 10_000 }),
+              wiringBase,
+            ),
+          })
+        : { checked: 0, unwired: [], failure: 'resolved-base-unavailable' };
+      const wiringObservation = {
+        round,
+        checked: wiring.checked,
+        unwired: wiring.unwired.length,
+        examples: wiring.unwired.slice(0, 10),
+        ...(wiring.failure ? { failure: wiring.failure } : {}),
+        mode: 'warn',
+      };
+      debug.log('self-implement.wiring-check', wiring.failure ? 'unmeasured' : 'measured', wiringObservation);
+      observe('wiring-check', wiringObservation, wiring.failure || wiring.unwired.length ? { level: 'warn' } : {});
+    }
     if ([...(runFacts.changedFiles ?? []), ...(gateRouteFiles ?? []), ...untrackedFiles].some((file) => /\.(?:html|css)$/i.test(file))) {
       try {
         designGate = (s.runDesignGate ?? runDesignGate)({ projectDir: wt.path, base: wt.resolvedBase });
@@ -7600,7 +7901,8 @@ async function runSelfImplementInner(
     const reviewContext = {
       runId,
       ...runFacts,
-      goal: opts.feature,
+      // E3 — refine 뒤 라운드의 리뷰는 «현재 골»(v2)로 판정한다. v1 은 PR «골 변경» 절에만 남는다(리뷰 r1 must-fix).
+      goal: roundGoal,
       goalFile: opts.goalFile,
       ...(priorRunFindings.length ? { priorRunFindings } : {}),
       ...(goalDocumentPath ? { goalDocumentPath } : {}),
@@ -7721,7 +8023,7 @@ async function runSelfImplementInner(
         }, { category: 'self-dev.rework' });
       }
       const refutations = refutableFindings.length
-        ? parseMustFixRefutations(impl.summary, opts.feature, refutableFindings, ({ stage, findingId }) => {
+        ? parseMustFixRefutations(impl.summary, roundGoal, refutableFindings, ({ stage, findingId }) => {
           observe('refute-rejected', { round, stage, ...(findingId ? { findingId } : {}) });
         }, { citedPathFacts, round })
         : [];
@@ -7753,7 +8055,7 @@ async function runSelfImplementInner(
         try {
           const originalMustFix = refutableFindings.map((finding) => finding.item);
           const recurrenceHistory = recurrenceHistoryFor(originalMustFix);
-          const adjudicated = await withStepTimeout(s.reflectMustFix({ mustFix: originalMustFix, goal: opts.feature, cwd: wt.path, evidenceFacts, gateFacts: gate.reflectGateFacts, refutations, citedPathFacts, ...(recurrenceHistory.length ? { recurrenceHistory } : {}), runId, round }), T.review, 'review');
+          const adjudicated = await withStepTimeout(s.reflectMustFix({ mustFix: originalMustFix, goal: roundGoal, cwd: wt.path, evidenceFacts, gateFacts: gate.reflectGateFacts, refutations, citedPathFacts, ...(recurrenceHistory.length ? { recurrenceHistory } : {}), runId, round }), T.review, 'review');
           observe('review-refute-adjudicated', {
             round,
             submittedCount: refutations.length,
@@ -7771,7 +8073,7 @@ async function runSelfImplementInner(
           const oneLine = (text: string): string => text.replace(/\s+/g, ' ').trim().slice(0, 60);
           try {
             const recurrenceHistory = recurrenceHistoryFor(review.mustFix);
-            const reflected = await withStepTimeout(s.reflectMustFix({ mustFix: review.mustFix, goal: opts.feature, cwd: wt.path, evidenceFacts, gateFacts: gate.reflectGateFacts, citedPathFacts, ...(recurrenceHistory.length ? { recurrenceHistory } : {}), runId, round }), T.review, 'review');
+            const reflected = await withStepTimeout(s.reflectMustFix({ mustFix: review.mustFix, goal: roundGoal, cwd: wt.path, evidenceFacts, gateFacts: gate.reflectGateFacts, citedPathFacts, ...(recurrenceHistory.length ? { recurrenceHistory } : {}), runId, round }), T.review, 'review');
             const rejectedItems = new Set(reflected.rejected.filter((r) => r.reason && r.reason.trim().length > 0).map((r) => r.item));
             const rejected = reflected.rejected.filter((r) => rejectedItems.has(r.item));
             effectiveMustFix = review.mustFix.filter((m) => !rejectedItems.has(m));
@@ -7872,7 +8174,7 @@ async function runSelfImplementInner(
     }
     // EVIDENCE-WIRING-EXEMPT — a commandless [preservation] is covered once the changed-file gate passed.
     if (gate.passed && evidenceCoverage?.uncoveredCount) {
-      const settledByGate = settleUncoveredEvidence(evidenceCoverage.uncovered, { gatePassed: true, required: requiredEvidenceFromGoal(opts.feature) });
+      const settledByGate = settleUncoveredEvidence(evidenceCoverage.uncovered, { gatePassed: true, required: requiredEvidenceFromGoal(roundGoal) });
       if (settledByGate.coveredByGate.length) {
         debug.log('self-implement.evidence', 'covered-by-gate', { round, tags: settledByGate.coveredByGate });
         evidenceCoverage = { ...evidenceCoverage, uncovered: settledByGate.uncovered, uncoveredCount: settledByGate.uncovered.length };
@@ -7910,6 +8212,7 @@ async function runSelfImplementInner(
 
   const { decisionSignalPress, decisionSignalPressReason } = resolveDecisionSignalPress(opts.goalFile, wt.path, opts.decisionSignalPressSources);
   const decisionSignalResult = decisionSignalPress ? { decisionSignalPress } : {};
+  const scopeExpansionResult = scopeExpansion ? { scopeExpansion } : {};
   const decisionSignalRed = (decisionSignalPress?.pressedRed.length ?? 0) > 0;
   const decisionSignalBaselineOnly = decisionSignalPress?.pressedBaselineOnly.length ?? 0;
   const preservedCompletionResult = !decisionSignalRed && completionDisposition
@@ -7939,10 +8242,13 @@ async function runSelfImplementInner(
   //     (모집단 0인데 distinguishes=1) 틀린 값으로 막으면 새 병목이 된다.
   //   ⛔ `ran === false`(skipped)는 «다른 것»이다 — 자식이 테스트를 안 건드린 경우이고
   //     그건 `skippedReason` 이 이미 가른다. 그래서 여기 조건에 넣지 않는다.
-  const verifyInconclusive = gate.verifyByBreaking?.ran === true && (gate.verifyByBreaking.distinguishes ?? 0) === 0;
-  const verifyNothingAtBase = verifyInconclusive && (gate.verifyByBreaking?.missingAtBase ?? 0) > 0;
+  // A new test absent from the fixed base is a structural RED witness when the
+  // head gate passed. Keep that distinct from an executed test that proved nothing.
+  const verifyStructuralRed = gate.verifyByBreaking?.ran === true && (gate.verifyByBreaking.missingAtBase ?? 0) > 0;
+  const verifyInconclusive = gate.verifyByBreaking?.ran === true
+    && (gate.verifyByBreaking.distinguishes ?? 0) === 0 && !verifyStructuralRed;
   let mergeReason = canAuto && reviewDeferredToHost ? REVIEW_DEFERRED_TO_HOST_MERGE_REASON
-    : canAuto ? (verifyNothingAtBase ? 'review-clean-verify-nothing-at-base' : verifyInconclusive ? 'review-clean-verify-inconclusive' : 'review-clean-armed')
+    : canAuto ? (verifyStructuralRed ? 'review-clean-verify-structural-red' : verifyInconclusive ? 'review-clean-verify-inconclusive' : 'review-clean-armed')
     : gateTimeoutUnmeasured ? GATE_TIMEOUT_UNMEASURED_MERGE_REASON
     : !autoMerge ? 'no-auto-flag'
       : requiredEvidenceMissing ? 'required-evidence-uncovered'
@@ -7990,7 +8296,7 @@ async function runSelfImplementInner(
     progress('worktree-completed', '✅ 작업 트리 완료 — PR 생성 없이 worktree 보존');
     observe('worktree-completed', { branch: wt.branch, hadApprover: !!s.approvePr });
     return {
-      ok: true, stage: 'worktree-completed', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}),
+      ok: true, stage: 'worktree-completed', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}),
       detail: 'worktree-only completion: PR creation skipped',
     };
   }
@@ -8001,7 +8307,7 @@ async function runSelfImplementInner(
     recordMergeDecision();
     observe('pr-declined', { branch: wt.branch, hadApprover: !!s.approvePr });
     return {
-      ok: false, stage: 'pr-declined', node: 'open-pr', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}),
+      ok: false, stage: 'pr-declined', node: 'open-pr', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}),
       detail: s.approvePr ? 'PR not approved' : 'no approvePr seam — fail-closed(자동승인 금지)',
     };
   }
@@ -8012,7 +8318,7 @@ async function runSelfImplementInner(
     if (opts.goalFile) {
       try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { /* no documented targets */ }
     }
-    inspectStaleReverts(revertGuardTargetPaths(opts.feature, goalDocument));
+    inspectStaleReverts(revertGuardTargetPaths(roundGoal, goalDocument)); // E3 — refine 뒤 v2 «대상 경로»
     s.commitWork(wt.path, prTitle(opts.feature, opts.goalFile));
     // ⛔⭐ resume 경로와 «같은» 해석기를 쓴다 — 두 자리가 갈리면 같은 원인이 다른 얼굴로 나온다.
     const resolvedTarget = resolveDefaultBranchTarget(s.defaultBranchRef ?? defaultBranchRef, wt.path);
@@ -8027,7 +8333,7 @@ async function runSelfImplementInner(
       canAuto = false;
       mergeReason = 'default-branch-unresolved';
       recordMergeDecision();
-      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), detail: 'pre-PR main sync default-branch-unresolved' };
+      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), detail: 'pre-PR main sync default-branch-unresolved' };
     }
     progress('gating', `최신 ${mergeTarget} 정합 (병렬 드리프트·LLM 충돌해결)…`);
     onMainSyncStarted((s.headCommit ?? ((cwd: string) => {
@@ -8045,7 +8351,7 @@ async function runSelfImplementInner(
       mergeReason = 'main-sync-interrupted';
       recordMergeDecision();
       progress('merge-conflict', `⚠️ ${mergeTarget} 정합 중단 — 사람 수확 (${wt.branch})`);
-      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), harvestable: true, detail: `pre-PR main sync interrupted: ${safeErrorDescription(error)}` };
+      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), harvestable: true, detail: `pre-PR main sync interrupted: ${safeErrorDescription(error)}` };
     }
     // ⛔⭐ `OBS-T96` 🅐 — 「무엇을 봤는지」를 남긴다. 수만 남기면 정합 실패가 «재현 불가»가 된다.
     observe('pre-pr-sync', mainSyncObservation(sync, mergeTarget, opts.base, wt.branch));
@@ -8056,7 +8362,7 @@ async function runSelfImplementInner(
       recordMergeDecision();
       const harvestable = (sync.reason === 'conflict-input-too-large' || sync.reason === 'conflict-resolver-interrupted')
         && await preserveMergeHarvest(sync.reason, sync.inputChars);
-      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(harvestable ? { harvestable: true } : {}), detail: harvestable ? sync.reason === 'conflict-input-too-large' ? `충돌 큼 — 사람 수확 (${wt.branch}, 입력 ${sync.inputChars}자)` : `충돌 해결 중단 — 사람 수확 (${wt.branch})` : `pre-PR main sync ${sync.status}` };
+      return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(harvestable ? { harvestable: true } : {}), detail: harvestable ? sync.reason === 'conflict-input-too-large' ? `충돌 큼 — 사람 수확 (${wt.branch}, 입력 ${sync.inputChars}자)` : `충돌 해결 중단 — 사람 수확 (${wt.branch})` : `pre-PR main sync ${sync.status}` };
     }
     if (sync.status === 'llm-resolved' || sync.status === 'merged' || sync.status === 'deterministic-resolved') {
       preservationBase = opts.base ?? mergeTarget;
@@ -8115,7 +8421,7 @@ async function runSelfImplementInner(
         mergeReason = 'post-sync-gate-failed';
         recordMergeDecision();
         const pr = await preserveBlockedArtifacts({ stage: 'gate-failed', reason, gate: regate, salvageStatusExpected: false });
-        return { ok: false, stage: 'gate-failed', node: 'regate', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate: regate, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(review ? { review } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
+        return { ok: false, stage: 'gate-failed', node: 'regate', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate: regate, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(review ? { review } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
       }
       if (!regate.passed) {
         progress('gating', timeoutOnlyPostSync
@@ -8129,7 +8435,7 @@ async function runSelfImplementInner(
   recordMergeDecision();
   if (!approved) {
     observe('pr-declined', { branch: wt.branch, hadApprover: !!s.approvePr });
-    return { ok: false, stage: 'pr-declined', node: 'open-pr', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason, detail: s.approvePr ? 'PR not approved' : 'no approvePr seam — fail-closed(자동승인 금지)' };
+    return { ok: false, stage: 'pr-declined', node: 'open-pr', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason, detail: s.approvePr ? 'PR not approved' : 'no approvePr seam — fail-closed(자동승인 금지)' };
   }
   if (canAuto) onMergeApprovalReceived();
   const extractedOriginalAsk = extractVerbatimOriginalAsk(opts.feature);
@@ -8164,7 +8470,7 @@ async function runSelfImplementInner(
   }
   const stoppedBeforePr = honorParentSoftStop('open-pr');
   if (stoppedBeforePr) {
-    return { ...stoppedBeforePr, ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}) };
+    return { ...stoppedBeforePr, ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, ...scopeExpansionResult, sessionId, gate, ...(review ? { review } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}) };
   }
   progress('pr-opening', 'PR 생성…');
   onNodeEntry('open-pr', round);
@@ -8204,7 +8510,8 @@ async function runSelfImplementInner(
   addNextMdReleaseNote(wt.path, releaseNote);
   const preparedPrBody = preparePrBody(
     [
-      prBody(opts.feature, impl.summary, gate.log, review, reviewIntent, declineReasons, harvestedForPr(), opts.goalFile, lastPlanRevision, releaseNote, revertGuard),
+      prBody(roundGoal, impl.summary, gate.log, review, reviewIntent, declineReasons, harvestedForPr(), opts.goalFile, lastPlanRevision, releaseNote, revertGuard) + renderScopeExpansionSection(scopeExpansion),
+      ...(goalRefinement ? ['', (await import('./goal-refine.js')).renderGoalChangeSection(goalRefinement)] : []),
       ...(prEvidenceDecision.body ? ['', '---', '', prEvidenceDecision.body] : []),
     ].join('\n'),
     s.persistPrBodyArtifact,
@@ -8214,6 +8521,7 @@ async function runSelfImplementInner(
   try {
     pr = await withStepTimeout(s.openPr({
       title: prTitle(opts.feature, opts.goalFile),
+      runId,
       body: preparedPrBody.body,
       head: wt.branch,
       ...(opts.base ? { base: opts.base } : {}),
@@ -8290,7 +8598,7 @@ async function runSelfImplementInner(
     }
     recordMergeDecision();
     progress('pr-opened', `OP 승인 대기 (#${pr.number}): ${releaseHoldPath}`);
-    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number, detail: `OP approval required: ${releaseHoldPath}` };
+    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number, detail: `OP approval required: ${releaseHoldPath}` };
   }
   if (!releasePathInspectionError && labels?.includes(AUTO_REVIEW_LABEL)) {
     try {
@@ -8308,7 +8616,7 @@ async function runSelfImplementInner(
       : 'release-path-inspection-failed';
     recordMergeDecision();
     progress('pr-opened', `OP 승인 대기 (#${pr.number}): PR 경로 조회 실패`);
-    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number };
+    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number };
   }
 
   if (canAuto && (s.mergePr || opts.mergeByHost)) {
@@ -8358,12 +8666,12 @@ async function runSelfImplementInner(
       //    판정(mergeReason)이 아니라 «집행 직전 가드»가 막았으므로 그 사실을 값으로 말한다.
       //    ⛔ 안 그러면 마지막 줄이 침묵하고, 그건 이 착지가 없애려던 상태다(리뷰 must-fix 2R).
       const guardSkipReason = mergeSkipReason ?? (guardFailure ? 'merge-guard-unevaluated' : 'docs-deletion-threshold');
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: guardSkipReason, prUrl: pr.url, prNumber: pr.number, detail };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: guardSkipReason, prUrl: pr.url, prNumber: pr.number, detail };
     }
     if (opts.mergeByHost) {
       observe('merge-ready', { number: pr.number, checkedHeadCommit });
       progress('pr-opened', `호스트 재게이트 대기 (#${pr.number})`);
-      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(reviewDeferredToHost ? { mergeReason } : {}), checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
+      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(reviewDeferredToHost ? { mergeReason } : {}), checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
     }
     // Landing freeze: the in-flight marker is written before the freeze is read, so a `freeze on` racing this merge waits.
     // The resume sweep merges from the repository that owns the run worktree (the worktree itself may be cleaned up).
@@ -8375,13 +8683,13 @@ async function runSelfImplementInner(
     };
     const landing = admitLandingMerge(heldEntry, undefined, {}, { prNumber: pr.number, repoRoot: owningRepoRoot(wt.path) ?? wt.path, ...(checkedHeadCommit ? { headCommit: checkedHeadCommit } : {}) });
     if (landing.kind === 'held' && !(checkedHeadCommit && /^[0-9a-f]{40}$/i.test(checkedHeadCommit))) {
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: 'merge-guard-unevaluated', prUrl: pr.url, prNumber: pr.number, detail: 'freeze: checked head SHA unavailable; PR left ready for review' };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: 'merge-guard-unevaluated', prUrl: pr.url, prNumber: pr.number, detail: 'freeze: checked head SHA unavailable; PR left ready for review' };
     }
     if (landing.kind !== 'merge') {
       const detail = landing.kind === 'held' ? landingFreezeMessage(landing.freeze) : 'freeze lifted; a resume sweep is merging this PR';
       debug.log('harness.merge', 'frozen', { pr: pr.number, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
       progress('pr-opened', `#${pr.number} ready · ${detail}`);
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: landing.kind === 'held' ? 'frozen' : 'resumed-elsewhere', prUrl: pr.url, prNumber: pr.number, detail };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: landing.kind === 'held' ? 'frozen' : 'resumed-elsewhere', prUrl: pr.url, prNumber: pr.number, detail };
     }
     // The marker and claim live until the merge call itself settles — a step timeout does not stop a merge already
     // sent — and anything that throws before the merge call is made releases them.
@@ -8464,17 +8772,17 @@ async function runSelfImplementInner(
         ...(opts.goalId ? { cellId: opts.goalId } : {}),
         ...(opts.goalFile ? { goalFile: opts.goalFile } : {}),
       }, s.followUp);
-      return { ok: true, stage: 'merged', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), merged: true, ...(mergedBase ? { mergedBase } : {}), prUrl: pr.url, prNumber: pr.number };
+      return { ok: true, stage: 'merged', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), merged: true, ...(mergedBase ? { mergedBase } : {}), prUrl: pr.url, prNumber: pr.number };
     }
     progress('pr-opened', `병합 실패 — PR 개설됨(#${pr.number}·수동 병합). ${m.detail ?? ''}`);
     // ⛔⭐ 이 경로는 `canAuto` 가 «참»이었는데 병합이 안 된 자리다 ⇒ mergeSkipReason 은 undefined 다.
     //    그대로 두면 마지막 산출 줄이 «침묵»한다 — 이 착지가 없애려던 바로 그 상태다(리뷰 must-fix).
     //    ⇒ 판정이 아니라 «집행»에서 막힌 것이므로 그 사실을 별도 값으로 말한다.
     const mergeAttemptSkipReason = mergeSkipReason ?? 'merge-attempt-failed';
-    return { ok: true, stage: 'pr-opened', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: mergeAttemptSkipReason, merged: false, prUrl: pr.url, prNumber: pr.number, ...(m.detail ? { detail: m.detail } : {}) };
+    return { ok: true, stage: 'pr-opened', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: mergeAttemptSkipReason, merged: false, prUrl: pr.url, prNumber: pr.number, ...(m.detail ? { detail: m.detail } : {}) };
   }
   progress('pr-opened', `✅ PR 개설 (#${pr.number})`);
-  return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}), prUrl: pr.url, prNumber: pr.number };
+  return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...scopeExpansionResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}), prUrl: pr.url, prNumber: pr.number };
 }
 
 /** 결정적 요청 거부 — 같은 요청을 다시 보내면 «같은» 답이 온다(BACKLOG B6).