elanous 0.2.34 → 0.2.36

package/src/self-implement/seams.ts

@@ -91,7 +91,7 @@ import { emitDecision } from '../live/detail-switch.js';
 import { gateDecision, reviewDecision, mergeDecision } from './decision-events.js';
 import { LogStore } from '../mss/logging/log-store.js';
 import { instanceNameForStateDir } from '../instance-identity.js';
-import { queryStructuredChildProviderErrors } from './orchestrator.js';
+import { queryStructuredChildProviderErrors, readHarvestPrBody, updateHarvestPrBody } from './orchestrator.js';
 import { buildImplementReport } from './off-diff-evidence.js';
 import { countReflectFactConflicts, type MustFixRefutation, type ReflectEvidenceFacts, type ReflectGateFacts } from './reflect-mustfix.js';
 import { isSupervisorDecisionSection, splitGoalSections, supervisorGoalDigest } from './goal-digest.js';
@@ -202,6 +202,11 @@ export function observeGateBaselineLocation(cwd: string): { branch: string | nul
 /** self-implement 자식만의 종료 보고 보존 규칙. 범용 control brain 기본 프롬프트에는 넣지 않는다. */
 export const SELF_IMPLEMENT_COMPLETION_REPORT_HINT = '자식이 최종 요약 또는 GOAL-COMPLETE 완료 마커를 출력 중이면 목표가 달성돼 보여도 done이 아니라 wait을 선택하라. 완료 보고가 끝날 때까지 기다려야 한다.';
 
+/** Set by the Kubernetes Job manifest only for the Pod child process. */
+export function podChildDependenciesRequired(env: NodeJS.ProcessEnv): boolean {
+  return Boolean(env.ELANOUS_POD_NAME?.trim());
+}
+
 /** self-implement 실행 경계가 범용 brain에 전용 종료-보고 규칙을 주입한다. */
 export function createSelfImplementControlBrain(opts: Omit<LlmControlBrainOpts, 'systemHint'>) {
   // ⭐ 이 부모에 쓸 provider 가 «하나도» 없으면(NoLlmProviderAvailableError) BRAIN-FAST 이전처럼 «지연 해석»
@@ -1260,11 +1265,126 @@ type DefaultSeamsDiagnoseInput = Omit<Parameters<NonNullable<SelfImplementSeams[
   kind: SupervisionReworkSource;
 };
 
-type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose'> & {
+/** 같은 칸 카드 재결속 사유 — debug.log `same-cell-card-rebind-<reason>` 이름과 1:1 로 대응한다. */
+export type SameCellCardRebindReason =
+  | 'card-id-absent'
+  | 'card-store-absent'
+  | 'card-missing'
+  | 'manual-ref'
+  | 'bound-other-pr'
+  | 'already-rebound'
+  | 'rebound'
+  | 'card-store-unreadable';
+
+/** openPr 반환이 싣는 재결속 관측 — `deferred` 면 PR 은 열렸고 카드 결속은 부모 pr-terminal(#29948) 몫이다. */
+export interface SameCellCardRebindObservation {
+  outcome: 'rebound' | 'already-rebound' | 'deferred';
+  reason: SameCellCardRebindReason;
+  cardId: string | null;
+  oldPr: number;
+  newPr: number;
+  boundPr?: number;
+  detail?: string;
+}
+
+export type OpenPrOutcome = { url: string; number: number; rebind?: SameCellCardRebindObservation };
+
+type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose' | 'openPr'> & {
   diagnose: (ctx: DefaultSeamsDiagnoseInput) => Promise<string>;
   closePr: (prUrl: string, comment?: string) => boolean;
+  openPr: (input: Parameters<NonNullable<SelfImplementSeams['openPr']>>[0]) => Promise<OpenPrOutcome>;
 };
 
+type SameCellRebindDecision =
+  | { kind: 'rebound' }
+  | { kind: 'already-rebound' }
+  | { kind: 'card-missing' }
+  | { kind: 'manual-ref' }
+  | { kind: 'bound-other-pr'; boundPr: number };
+
+type SameCellRebindExtra = { boundPr?: number; detail?: string };
+
+/** 같은 칸 새 draft 뒤 카드 재결속 — 사유를 다섯 갈래로 나눠 남기고, 카드 저장소가 없는 실행은 던지지 않고
+ *  deferred 로 돌려준다(Pod 자식은 본부 카드 저장소가 없다 · 부모 pr-terminal 결속은 #29948 이 맡는다). */
+function rebindSameCellCardToPr(input: {
+  taskCardId: string | undefined;
+  storePath: string;
+  oldPr: number;
+  newPr: number;
+  url: string;
+}): SameCellCardRebindObservation {
+  const cardId = input.taskCardId ?? null;
+  const base = { cardId, oldPr: input.oldPr, newPr: input.newPr, url: input.url };
+  const observe = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}, level: 'info' | 'warn' = 'info'): void => {
+    debug.log('self-implement.pr', `same-cell-card-rebind-${reason}`, { ...base, ...extra }, { level });
+  };
+  const deferred = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): SameCellCardRebindObservation => {
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-deferred', { ...base, ...extra, reason }, { level: 'warn' });
+    return { outcome: 'deferred', reason, cardId, oldPr: input.oldPr, newPr: input.newPr, ...extra };
+  };
+  const failed = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): never => {
+    const reasonText = reason === 'bound-other-pr' ? `bound-other-pr(${String(extra.boundPr)})` : reason;
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-failed', { ...base, ...extra, reason }, { level: 'warn' });
+    throw new Error(`same-cell 새 draft ${input.url} 개설됨; 카드 재결속 실패(${reasonText}) — 새 PR 수확 필요`);
+  };
+  if (!input.taskCardId) return deferred('card-id-absent');
+  if (!existsSync(input.storePath)) return deferred('card-store-absent');
+  let decision: SameCellRebindDecision | undefined;
+  let updated: ReturnType<typeof updateTaskCard>;
+  try {
+    updated = updateTaskCard(input.storePath, input.taskCardId, (card) => {
+      if (!card) {
+        decision = { kind: 'card-missing' };
+        return undefined;
+      }
+      if (card.refSource === 'manual') {
+        decision = { kind: 'manual-ref' };
+        return undefined;
+      }
+      const currentPr = cardPrNumber(card);
+      if (currentPr !== undefined && currentPr !== input.oldPr && currentPr !== input.newPr) {
+        decision = { kind: 'bound-other-pr', boundPr: currentPr };
+        return undefined;
+      }
+      if (currentPr === input.newPr && card.history.some((event) => event.event === 'same-cell-pr-rebound' && event.pr === input.newPr)) {
+        decision = { kind: 'already-rebound' };
+        return undefined;
+      }
+      decision = { kind: 'rebound' };
+      return {
+        ...card,
+        pr: { number: input.newPr, url: input.url },
+        history: [...card.history, {
+          at: new Date().toISOString(), event: 'same-cell-pr-rebound', pr: input.newPr,
+          detail: `이전 draft #${input.oldPr} 정리 후속 · 새 PR #${input.newPr} 결속`,
+        }],
+      };
+    });
+  } catch (error) {
+    return failed('card-store-unreadable', { detail: error instanceof Error ? error.message : String(error) });
+  }
+  const decided: SameCellRebindDecision = decision ?? { kind: 'card-missing' };
+  switch (decided.kind) {
+    case 'bound-other-pr':
+      return failed('bound-other-pr', { boundPr: decided.boundPr });
+    case 'manual-ref':
+      return failed('manual-ref');
+    case 'card-missing':
+      return deferred('card-missing');
+    case 'already-rebound':
+      observe('already-rebound');
+      return { outcome: 'already-rebound', reason: 'already-rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+    case 'rebound':
+      if (!updated || cardPrNumber(updated) !== input.newPr) {
+        return failed('card-store-unreadable', { detail: '카드 갱신 결과가 새 PR 을 가리키지 않는다' });
+      }
+      observe('rebound');
+      return { outcome: 'rebound', reason: 'rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+  }
+}
+
 const GOAL_DESCRIPTION_MAX_CHARS = 250;
 const DEFAULT_GOAL_SUMMARY_TIMEOUT_MS = 10_000;
 
@@ -1624,6 +1744,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         worktreeRoot: configuredWorktreeRoot(),
         resetExisting: true,
         reuseOwnedWorktree: true,
+        requireDependencies: podChildDependenciesRequired(process.env),
         ...(base ? { base } : {}),
         ...(runId ? { currentOwner: `dev:${runId}` } : {}),
       });
@@ -1791,6 +1912,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
             ...(onProgress ? { onProgress } : {}), // part2-B — execute judge 로 라이브 델타 전달(PTY 경로만).
             ...(onSurfaceProgress ? { onSurfaceProgress } : {}), // Sparse parent-surface lines; raw execute-judge delta remains onProgress only.
             ...(onSupervisorInput ? { onSupervisorInput } : {}),
+            ...(process.env.ELANOUS_POD_VERIFIED_PR_SOURCE === '1' ? { verifiedPrSource: true } : {}),
             ...(onLifecycleScreenClassification ? { onLifecycleScreenClassification } : {}),
             ...(roundContext ? { roundContext } : {}),
           });
@@ -2194,7 +2316,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   `tc`(변경파일 tsc) **전에** 실행해서, tsc 가 깨져 **최종 게이트가 실패한 런에도**
       //   base 를 다시 돌리고 `gate.log` 를 바꿨다 ⇒ *"게이트 실패 경로 무변경"* 경계 위반.
       //   ⇒ 조건을 최종 판정과 같은 식으로 묶는다.
-      const gatePassed = !comparisonFailureReason && !unmeasuredPostsync && integrityPassed && tc.passed && policy.passed && expose.passed && (dependencyGate?.passed ?? true);
+      let gatePassed = !comparisonFailureReason && !unmeasuredPostsync && integrityPassed && tc.passed && policy.passed && expose.passed && (dependencyGate?.passed ?? true);
+      let changedTestEvidenceNote = '';
       const verifyIdentity = gateVerifyIdentity(ctx?.runId);
       if (gatePassed && scope.skipTestStep) {
         verifyByBreaking = { ran: false, distinguishes: 0, 'does-not-distinguish': 0, unknown: 0, skippedReason: scope.reason };
@@ -2237,6 +2360,34 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         //     그것을 검사하는 테스트는 아무것도 증명하지 못한다(리뷰 2R 이 그 Goodhart 를 잡았다).
         const editedTests = scope.testArgs!.filter((file) => !scope.pulledInRelatedTests.includes(file));
         const verify = (o.runVerifyByBreaking ?? runVerifyByBreaking)(cwd, editedTests, baselineRefs.get(cwd));
+        // A passing head bundle covers all edited tests. An existing test needs a
+        // measured failing base run. A new test absent from the fixed base is a
+        // structural RED witness even when copying it to base cannot load its new
+        // module/export; that loader failure is not an executable base assertion.
+        // Mobile base measurement is separate and is not a RED witness here.
+        const measured = new Map(verify.files.map((entry) => [entry.file, entry]));
+        const eligible = editedTests.filter((file) => /\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(file));
+        const red = eligible.filter((file) => {
+          const entry = measured.get(file);
+          return entry?.classification === 'missing-at-base'
+            || (entry?.classification === 'distinguishes' && entry.base.status === 'test-fail');
+        });
+        const structuralRed = red.filter((file) => measured.get(file)?.classification === 'missing-at-base');
+        const executedBaseFailures = red.length - structuralRed.length;
+        const complete = eligible.length === 0 || red.length > 0;
+        changedTestEvidenceNote = `\n\n[changed-test-evidence] head=pass; base-fail=${executedBaseFailures}/${eligible.length}; red-witness=${red.length}/${eligible.length}; verdict=${eligible.length === 0 ? 'not-applicable' : complete ? 'proved' : 'unproved'}`
+          + `; red-missing-at-base=${structuralRed.length}`
+          + (structuralRed.length > 0
+            ? '; structural-red=the new test file is absent from the fixed base, so a runnable base assertion is not required'
+            : '')
+          + (!complete ? `; no-red-witness=${eligible.join(', ')}` : '')
+          + (editedTests.length !== eligible.length ? `; mobile-or-other-excluded=${editedTests.length - eligible.length}` : '');
+        debug.log('self-implement', 'gate.changed-test-evidence', {
+          head: 'pass', baseFailed: executedBaseFailures, redWitnesses: red.length, edited: editedTests.length,
+          eligible: eligible.length, verdict: eligible.length === 0 ? 'not-applicable' : complete ? 'proved' : 'unproved', red,
+          redMissingAtBase: structuralRed,
+        }, { level: complete ? 'info' : 'warn' });
+        if (!complete) gatePassed = false;
         // ⛔⭐⭐⭐ **조건은 테스트 전용 변경이나 특정 정방향 분류가 아니라, 편집 테스트의 네 정방향 분류 전체다.**
         //   (리뷰 R3 must-fix — 내가 PR 경계에 *"혼합 변경에서는 조건상 안 돈다"* 고 «틀리게» 적었다).
         //   ⇒ 소스와 테스트가 «함께» 바뀐 PR 에서도 그 분류가 나오면 «돈다». 그리고 그게 맞다:
@@ -2308,6 +2459,14 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           skipped: true, reason: why, testStep: why, ...verifyIdentity, ...emptyVerifyCounts,
         }, { level: 'warn' });
       }
+      if (gatePassed && scope.reason === 'changed-tests' && !changedTestEvidenceNote
+        && scope.testArgs?.some((file) => /\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(file))) {
+        gatePassed = false;
+        changedTestEvidenceNote = '\n\n[changed-test-evidence] verdict=unproved; head/base pair was not measured';
+        debug.log('self-implement', 'gate.changed-test-evidence', {
+          verdict: 'unproved', reason: 'head/base pair was not measured',
+        }, { level: 'warn' });
+      }
       // ⭐ 거짓통과 방지 표기(제1원칙 관측 · 2026-07-26) — test 스텝을 건너뛰면 `passed:true` 가
       //   **"검증됨"으로 오독**될 수 있다. 그건 integrity-gate 의 `ranNothing` 가드가 막으려던
       //   거짓통과를 스코프 축소가 우회로 되살리는 것이다 ⇒ 게이트 로그에 **명시**한다.
@@ -2370,7 +2529,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         : '';
       return {
         passed: gatePassed,
-        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}${callerOverflowNote}${routeLookupNote}${expose.log ? `\n\n${expose.log}` : ''}`,
+        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${changedTestEvidenceNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}${callerOverflowNote}${routeLookupNote}${expose.log ? `\n\n${expose.log}` : ''}`,
         testStepExecuted: !testStepSkipped && testStep !== undefined && !testStep.skipped,
         scopeReason,
         comparisonBaseStatus: observationChanges.comparisonBaseStatus,
@@ -2492,14 +2651,16 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     // ⛔ await 한다 — spawn 실패를 삼키면 발사 실패도 `salvage:'launched'` 로 거짓 관측된다(3차 M4).
     launchReworkSalvage: async (input) => { await launchReworkSalvage(input); },
 
-    openPr: async ({ title, body, head, base, draft, labels, cwd }) => {
+    openPr: async ({ title, body, head, base, draft, labels, cwd, runId }) => {
       const resolvedBase = assertBaseBranchOnOrigin(cwd, base);
       const harnessSeat = process.env.ELANOUS_HARNESS_SEAT;
       const taskCardId = process.env.ELANOUS_TASK_CARD_ID;
       const bodyWithCard = taskCardId && /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(taskCardId)
         ? `${body}\n\n카드: ${taskCardId}` : body;
+      const prRunId = runId ?? getHarnessRunId();
       const outcome = (o.prManager ?? makePrManager()).upsertPr({
         branch: head,
+        ...(prRunId ? { runId: prRunId } : {}),
         worktreePath: cwd,
         title,
         body: buildPrBody(cwd, bodyWithCard),
@@ -2515,34 +2676,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);
+      let rebind: SameCellCardRebindObservation | undefined;
       if (outcome.supersededPr && Number.isSafeInteger(number) && number > 0) {
-        const rebindFailed = (reason: string): never => {
-          debug.log('self-implement.pr', 'same-cell-card-rebind-failed', {
-            cardId: taskCardId ?? null, oldPr: outcome.supersededPr, newPr: number,
-            url: outcome.url, reason,
-          }, { level: 'warn' });
-          throw new Error(`same-cell 새 draft ${outcome.url} 개설됨; 카드 재결속 실패(${reason}) — 새 PR 수확 필요`);
-        };
         debug.log('self-implement.pr', 'same-cell-rebound', {
           cardId: taskCardId ?? null, oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
           oldDraftCleanup: 'deferred',
         });
-        const cardId = taskCardId ?? rebindFailed('카드 ID 없음');
-        let rebound: ReturnType<typeof updateTaskCard>;
-        try {
-          rebound = updateTaskCard(taskAgentStatePath(), cardId, (card) => {
-            if (!card || card.refSource === 'manual' || (cardPrNumber(card) !== undefined
-              && cardPrNumber(card) !== outcome.supersededPr && cardPrNumber(card) !== number)) return undefined;
-            if (cardPrNumber(card) === number && card.history.some((event) => event.event === 'same-cell-pr-rebound' && event.pr === number)) return undefined;
-            return { ...card, pr: { number, url: outcome.url }, history: [...card.history, {
-              at: new Date().toISOString(), event: 'same-cell-pr-rebound', pr: number,
-              detail: `이전 draft #${outcome.supersededPr} 정리 후속 · 새 PR #${number} 결속`,
-            }] };
-          });
-        } catch (error) { rebindFailed(error instanceof Error ? error.message : String(error)); }
-        if (!rebound || cardPrNumber(rebound) !== number) rebindFailed('카드 없음 또는 기존 PR 결속 충돌');
+        rebind = rebindSameCellCardToPr({
+          taskCardId, storePath: taskAgentStatePath(), oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
+        });
       }
-      return { url: outcome.url, number: Number.isFinite(number) ? number : 0 };
+      const opened: OpenPrOutcome = { url: outcome.url, number: Number.isFinite(number) ? number : 0, ...(rebind ? { rebind } : {}) };
+      return opened;
     },
 
     // 재발명 0 — PrManager.closePr 시그니처·동작을 그대로 위임한다(mission-lifecycle 이 이미 쓴다).
@@ -2604,6 +2749,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
       });
     },
+    readPrBodyForHarvest: readHarvestPrBody,
+    updatePrBodyForHarvest: updateHarvestPrBody,
     readPrFiles: async ({ number, cwd, base }) => readPrFilesWithRateLimitFallback({
       number, cwd, env: ghAutomationEnv(process.env), ...(base ? { base } : {}),
     }),
@@ -2720,6 +2867,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   소화(C1 Bug2 "replace it with" 자기모순류를 스스로 진단). llmReview(동일 LLM 래퍼) 재사용·fail-soft.
       judgmentCallLLM: async ({ prompt }) => o.llmReview!(prompt),
       classifyCallLLM: async ({ prompt }) => o.llmReview!(prompt),
+      // E1 GOAL-ELABORATE-ON-ARRIVAL — 착수 구체화 카드 작성·판정(같은 LLM 래퍼 · 실패는 카드 없이 진행).
+      elaborateCallLLM: async ({ prompt, systemPrompt }) => o.llmReview!(systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt),
       diagnose: async ({ runId, note, kind, round, goal, history, supervisorDecisionHistory = [], judgePredictionAccuracy: predictionAccuracy, effectiveMax, priorRuns, reviewFindingTelemetry, refutations = [], refutationRound, purpose = 'budget' }: DefaultSeamsDiagnoseInput): Promise<string> => {
         const goalDigest = supervisorGoalDigest(goal, 3000);
         const predictionAccuracyForPrompt = predictionAccuracy
@@ -2885,6 +3034,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           `첫 줄은 정확히 하나: BUDGET: EXTEND | BUDGET: SUFFICIENT | BUDGET: UNCONVERGEABLE | BUDGET: CONTRACT-CONFLICT`,
           `둘째 줄: REASON: <한 문장>. 이후에만 진단을 쓴다.`,
           `EXTEND는 새 지적이 좁아져 한 라운드 더로 풀릴 때만, SUFFICIENT는 리뷰만 실패했고 gate는 통과했으며 남은 지적이 비블로커·스코프 밖일 때만, UNCONVERGEABLE은 같은 지적 반복·스코프 밖 요구·근거 없는 반복 리뷰일 때다.`,
+          `단 구조적으로 불가능한 증거 요구(예: base 에 없는 신규 파일·모듈의 시험에 base 실패 목격을 요구 · [changed-test-evidence] verdict=unproved 가 missing-at-base 때문인 것)는 반복돼도 UNCONVERGEABLE 이 아니라 CONTRACT-CONFLICT 다(REASON 에 그 요구가 불가능한 이유). 조각 미션에서 다음 조각 몫(호출부·배선·후속 조각이 맡은 일)을 이번 조각에 요구하는 지적만 남았고 gate 가 통과했으면 SUFFICIENT 다.`,
           `CONTRACT-CONFLICT는 현장과 골의 수용·보존 계약 또는 리뷰 지적이 정면으로 충돌하여, 검증된 수용 기준 완화 뒤 다음 라운드가 수정된 골 기준으로 계속해야 할 때 쓴다. 타당한 자식 REFUTE는 이 판단의 근거가 될 수 있지만 제출이 없어도 구현과 계약만으로 동시에 만족시킬 수 없는 충돌이면 이 값을 선택한다. 이 경우 REASON에는 반드시 어떤 계획 줄이 현장과 어긋나는지 쓴다. 골의 ## ACCEPTANCE CRITERIA 안에서 정확히 한 수용 기준 행을 식별할 수 있으면 이어서 반드시 TARGET: <## ACCEPTANCE CRITERIA 안의 전체 원문 한 줄>, EXPECTED: <그 TARGET 행의 현재 한 줄>, REPLACEMENT: <그 TARGET 행에서 완화한 한 줄>을 각각 개행 없는 한 줄로 출력한다. TARGET은 첫 콜론 앞 접두·식별값이나 설명문이 아니라 수용 기준 행 전체와 정확히 일치해야 하며, EXPECTED와 REPLACEMENT도 같은 TARGET 행에서 유래한 단일 수용 기준 행이어야 한다. 셋 중 하나라도 확정할 수 없거나 대상·원문이 다중 일치하면 세 줄을 쓰지 말고 REASON에 적용 불가 사유만 기록한다.`,
           `REFUTE 제출이 있으면 각 항목을 실제로 판정한 경우에만 이후 줄에 정확히 \`REFUTE [findingId]: ACCEPT\` 또는 \`REFUTE [findingId]: REJECT\`로 남겨라. BUDGET verdict는 개별 REFUTE 판정이 아니며, REFUTE 줄이 없으면 개별 수락·기각은 기록되지 않는다.`,
           `너는 자율 구현 rework 진단가다. 현재 라운드 ${round}/${effectiveMax}, 종류는 ${kind}이다.`,
@@ -2901,7 +3051,16 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           `이후 진단은 다음 구현 에이전트가 근본부터 고치도록 각 항목에 1)왜 실패했나 2)어떻게 고칠까를 간결히 5개 이내로 쓴다.`,
         ].join('\n');
         try {
-          const out = await o.llmReview!(prompt);
+          const raw = await o.llmReview!(prompt);
+          const reclass = (await import('./rework-policy.js')).reclassifyImpossibleEvidence(raw, note);
+          const out = reclass.response;
+          if (reclass.applied) {
+            try {
+              debug.log('self-implement', 'supervisor-impossible-evidence', {
+                runId, kind, round, from: 'UNCONVERGEABLE', to: 'CONTRACT-CONFLICT', markers: reclass.markers,
+              });
+            } catch { /* 관측은 fail-soft */ }
+          }
           try {
             debug.log('self-implement', 'diagnose.done', {
               runId,

package/src/self-implement/stop-autoheal.ts

@@ -25,11 +25,15 @@
  * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
  */
 import { debug } from '../debug/log.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { withFileLockSync } from '../storage/file-lock.js';
 import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
 import type { GraphTemplateSpec } from './graph-yaml.js';
 import { GRAPH_SPECS } from './graph-templates.js';
 import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
-import type { RunStopClass, RunStopRecord } from './run-stop.js';
+import { boundRunStopCause, type RunStopClass, type RunStopRecord } from './run-stop.js';
 
 export const AUTOHEAL_EVENT = 'autoheal';
 export type AutohealMode = 'shadow' | 'live';
@@ -171,6 +175,80 @@ export interface AutohealDeps {
    * 안 주면 지금과 똑같이 동작한다.
    */
   priorStops?: readonly RunStopRecord[];
+  /** Parent-only candidate store. Omit in pure consumers/tests; the orchestrator supplies its instance root. */
+  knowhowCandidateDir?: string;
+}
+
+export type IntermediateStopReason = 'no-progress' | 'scope-escape' | 'wallclock-cap' | 'pod-job-failed';
+export interface StopKnowhowCandidate {
+  cell: string | null;
+  cellUnknownReason?: string;
+  reason: IntermediateStopReason;
+  stage: string;
+  stageUnknownReason?: string;
+  causeLine: string;
+  nextLaunchChange: string;
+  firstAt: string;
+  lastAt: string;
+  occurrences: number;
+  runIds: string[];
+}
+
+function intermediateStopReason(record: RunStopRecord): IntermediateStopReason | undefined {
+  const termination = record.childEvidence?.terminationReason;
+  if (record.class === 'scope-escape' || record.childEvidence?.scopeEscape === true || termination === 'scope-escape') return 'scope-escape';
+  if (termination === 'wallclock-cap') return 'wallclock-cap';
+  if (termination === 'no-progress') return 'no-progress';
+  if (record.terminationReason === 'pod-job-failed' || termination === 'pod-job-failed') return 'pod-job-failed';
+  return undefined;
+}
+
+const NEXT_LAUNCH_CHANGE: Record<IntermediateStopReason, string> = {
+  'no-progress': '골·완료 경계와 이미 끝난 범위를 다시 확인하고 남은 한 조각으로 고쳐 발사한다.',
+  'scope-escape': '허용 대상 경로와 범위 밖 편집 원문을 대조해 골의 경계를 수정한다.',
+  'wallclock-cap': '실행 시간을 넘긴 단계를 확인해 독립 조각으로 줄이고 중간 산출을 보존한다.',
+  'pod-job-failed': '자식 첫 오류와 Pod 종료 원인을 확인한 뒤 실행 환경 또는 골을 고쳐 발사한다.',
+};
+
+/** One file per cell and reason; the lock makes repeated parent stops one candidate. */
+export function captureStopKnowhowCandidate(ctx: AutohealContext, dir: string, now: () => Date = () => new Date()): { path: string; candidate: StopKnowhowCandidate; created: boolean } | undefined {
+  const reason = intermediateStopReason(ctx.record);
+  if (!reason) return undefined;
+  const cell = ctx.goalId?.trim() || null;
+  const key = createHash('sha256').update(`${cell ?? `unknown:${ctx.runId}`}\0${reason}`).digest('hex');
+  const path = join(dir, `${key}.json`);
+  mkdirSync(dir, { recursive: true });
+  return withFileLockSync(`${path}.lock`, () => {
+    const at = now().toISOString();
+    const old = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as StopKnowhowCandidate : undefined;
+    if (old?.runIds.includes(ctx.runId)) return { path, candidate: old, created: false };
+    const created = old === undefined;
+    const candidate: StopKnowhowCandidate = old ? {
+      ...old,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? { stageUnknownReason: undefined } : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      lastAt: at,
+      occurrences: old.occurrences + 1,
+      runIds: [...old.runIds, ctx.runId],
+    } : {
+      cell,
+      ...(cell ? {} : { cellUnknownReason: '칸 미상 · stop 호출에 goalId가 전달되지 않음' }),
+      reason,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? {} : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      nextLaunchChange: NEXT_LAUNCH_CHANGE[reason],
+      firstAt: at,
+      lastAt: at,
+      occurrences: 1,
+      runIds: [ctx.runId],
+    };
+    const temp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(candidate, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+    return { path, candidate, created };
+  });
 }
 
 /**
@@ -208,6 +286,14 @@ function observe(event: string, data: Record<string, unknown>): void {
  * stop 레코드 하나 → 최대 한 번의 힐 시도. 예외를 던지지 않는다(행동 seam 의 throw 도 needs-owner 로 접는다).
  */
 export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
+  if (deps.knowhowCandidateDir) {
+    try {
+      const captured = captureStopKnowhowCandidate(ctx, deps.knowhowCandidateDir);
+      if (captured) observe('knowhow-candidate', { runId: ctx.runId, cell: captured.candidate.cell, reason: captured.candidate.reason, created: captured.created, occurrences: captured.candidate.occurrences, path: captured.path });
+    } catch (error) {
+      observe('knowhow-candidate-failed', { runId: ctx.runId, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
   const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
   const cls = ctx.record.class;
   const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);