elanous 0.2.37 → 0.2.40

package/src/self-implement/orchestrator.ts

@@ -33,7 +33,7 @@ export {
 } from './pr-evidence-artifact.js';
 import { judgePredictionAccuracy } from './judge-prediction-accuracy.js';
 import { classifyPodReviewBudgetResidue, measureReviewFindingRecurrence, type ReviewFindingRecurrence, type RecurrenceFinding } from './review-finding-recurrence.js';
-import type { ReviewRework } from '../self-dev/run-types.js';
+import type { ReviewRework, SelfDevJobResult } from '../self-dev/run-types.js';
 import { createHash } from 'node:crypto';
 import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { writeGoalDocumentAtomic } from './goal-document-write.js';
@@ -226,7 +226,7 @@ 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, createRequiredEvidenceBudget, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { authorLimitationCountFromGoal, authoredSignalExecution, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, judgeTddEvidence, 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';
@@ -1107,6 +1107,8 @@ export interface SelfImplementSeams {
   synthesizeGoalContext?: (input: { goalFile?: string }) => Promise<Pick<import('../harness/harness-worktree-add.js').HarnessWorktreeGoalMetadata, 'goalTitle' | 'goalDescription' | 'goalDescriptionSource'>>;
   createWorktree: (opts: { branch: string; base?: string; runId?: string } & import('../harness/harness-worktree-add.js').HarnessWorktreeGoalMetadata) => Promise<{
     path: string; branch: string;
+    /** A single-use Pod may implement in its already checked-out source tree. */
+    inPlace?: boolean;
     /** Strict provenance values are returned only after their recording succeeds. */
     owner?: string;
     command?: string;
@@ -2178,6 +2180,8 @@ export function appendGoalExecutionRecord(goalFile: string, record: GoalExecutio
 }
 
 export interface SelfImplementOptions {
+  /** Parent managed-task cancellation, linked to the active implementation child. */
+  signal?: AbortSignal;
   /** ⭐ 걸음을 «호출부»로 흘리는 이음매 — 노드에 들어갈 때마다 한 번.
    *  🩸 2026-09-08: 이 콜백은 «내부에» 있었고 ***호출부가 0*** 이라 걸음이 런 밖으로 안 나갔다.
    *    ⇒ 런 슈퍼바이저는 「시도의 요약 판정」만 보고 「어떻게 걸었나」를 «못 봤다».
@@ -2355,6 +2359,8 @@ export interface SelfImplementResult {
   walk?: readonly { node: string; round: number }[];
   /** Canonical run-identity join key; always present because resolveRunIdentity always mints or inherits one. */
   runId: string;
+  /** Parent-observed goal-plan revision attempt evidence; omitted when no ledger evidence was read. */
+  goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
   ok: boolean;
   stage: SelfImplementStage;
   /** Verbatim must-fix findings retained on a review-blocked terminal result. */
@@ -3329,7 +3335,12 @@ async function runPostMergeCleanup(
   goalFile: string | undefined,
   remoteBranch: string | undefined,
   observe: (event: string, data: Record<string, unknown>) => void,
+  inPlace = false,
 ): Promise<void> {
+  if (inPlace) {
+    observe('post-merge-cleanup-preserved', { worktreePath, branch, reason: 'pod-inplace-source' });
+    return;
+  }
   if (!cleanup?.enabled) {
     observe('post-merge-cleanup-preserved', { worktreePath, branch, reason: cleanup ? 'disabled' : 'not-configured' });
     return;
@@ -5286,6 +5297,7 @@ async function runSelfImplementInner(
   observe('worktree', {
     path: wt.path,
     branch: wt.branch,
+    inPlace: wt.inPlace === true,
     terminalLaunchHead: terminalLaunchHead ?? null,
     terminalLaunchDirtyPaths: terminalLaunchDirtyPaths ? [...terminalLaunchDirtyPaths] : null,
     // ⭐ 우리가 **무엇을 요청했는지는 이미 안다** — 시임 반환에서 되읽지 않는다.
@@ -5306,7 +5318,7 @@ async function runSelfImplementInner(
   // ⛔ 발사 부모(`harness ask`·`dev`)에는 ELANOUS_HARNESS_SPACE_ID 가 «없다» — 그 env 는 자식에게만 심긴다.
   //   그래서 getHarnessSpace() 만 보면 운영에서 늘 undefined 이고 정지 확인이 «한 번도» 안 돈다(#20040 착지 직후 실측).
   //   `self send <space> --stop` 이 겨냥하는 것은 자식의 공간 = 워크트리 이름이다(아래 activeChildInboxId 와 같은 식 · dev-cli.ts recordRestart 폴백과 같다).
-  const parentSoftStopSpaceId = s.parentSoftStopSpaceId || getHarnessSpace()?.id || normalizeSpaceId(basename(wt.path)) || undefined;
+  const parentSoftStopSpaceId = s.parentSoftStopSpaceId || getHarnessSpace()?.id || normalizeSpaceId(wt.inPlace ? runId : basename(wt.path)) || undefined;
   if (parentSoftStopSpaceId) {
     try { s.onSoftStopSpaceReady?.(parentSoftStopSpaceId); } catch { /* UI registration must not break execution */ }
   }
@@ -5455,9 +5467,20 @@ async function runSelfImplementInner(
   }
 
   // The repository copy travels with both local and Pod worktrees. Operational HQ ledgers are never read here.
-  const knowhow = selectKnowhowPack(wt.path, opts.feature);
-  if (knowhow.text) round0Feature = `${knowhow.text}\n\n${round0Feature}`;
-  observe('knowhow-pack', { ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0 });
+  const knowhow = selectKnowhowPack(
+    wt.path,
+    opts.feature,
+    undefined,
+    { goalFile: opts.goalFile ?? null },
+  );
+  // Keep the original ask first: the child preflight and PR title read its first line.
+  const injectKnowhow = getUserConfig().harness?.knowhowChildInjection === true;
+  if (injectKnowhow && knowhow.text) round0Feature = `${round0Feature}\n\n${knowhow.text}`;
+  const knowhowRevisionRead = runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 });
+  const knowhowRevision = knowhowRevisionRead.status === 0 && /^[0-9a-f]{40,64}$/i.test(knowhowRevisionRead.stdout.trim())
+    ? knowhowRevisionRead.stdout.trim() : null;
+  observe('knowhow-pack', { goal: opts.feature.slice(0, 4096), ids: knowhow.ids, bytes: knowhow.bytes, sources: knowhow.sources ?? [], injected: injectKnowhow && knowhow.bytes > 0,
+    reason: knowhow.reason, knowhowReason: knowhow.knowhowReason ?? knowhow.reason, repoPath: wt.path, repoRevision: knowhowRevision });
 
   // 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 });
@@ -5523,7 +5546,7 @@ async function runSelfImplementInner(
     readonly update?: (delivery: SupervisorDeliveryState, reason?: string) => void;
   };
   let supervisorDeliveryUpdates: PendingSupervisorDelivery[] = [];
-  const activeChildInboxId = normalizeSpaceId(basename(wt.path));
+  const activeChildInboxId = normalizeSpaceId(wt.inPlace ? runId : basename(wt.path));
   const undeliveredSupervisorInputs: UndeliveredSupervisorInput[] = [];
   const recordUndeliveredSupervisorInput = (text: string, reason: string): void => {
     undeliveredSupervisorInputs.push({ text, reason });
@@ -7256,6 +7279,9 @@ async function runSelfImplementInner(
       throw error;
     }
     const implementAbortController = new AbortController();
+    const abortImplementation = (): void => implementAbortController.abort(opts.signal?.reason);
+    if (opts.signal?.aborted) abortImplementation();
+    else opts.signal?.addEventListener('abort', abortImplementation, { once: true });
     let implementPromise: ReturnType<SelfImplementSeams['implement']>;
     // Rework needs landed sibling PRs only after the initial round; shard eligibility avoids an expensive impossible lookup.
     const landedSiblings = round > 0
@@ -7322,7 +7348,10 @@ async function runSelfImplementInner(
       }
       finalizeSupervisorDeliveries(error instanceof StepTimeoutError ? 'next-round-implement-timeout' : 'next-round-implement-rejected');
       throw error;
+    } finally {
+      opts.signal?.removeEventListener('abort', abortImplementation);
     }
+    if (opts.signal?.aborted) throw opts.signal.reason ?? new Error('SelfImplement aborted');
     // ⭐ 성공 경로에서도 닫는다 — 이 호출은 끝났고, 이후 자식이 늦게 보내는 입력은
     //   「이 라운드의 재투입」이 아니다(다음 라운드는 자기 콜백을 새로 만든다).
     closeSupervisorInput();
@@ -7383,12 +7412,16 @@ async function runSelfImplementInner(
           try { after = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { /* unknown diff */ }
           const targetDiff = after === undefined ? undefined : eligible(after);
           const resultLine = /(?:^|\n)\s*RESULT:\s*\S/m.test(impl.evidenceTranscript ?? impl.summary);
-          const succeeded = impl.ok && !!targetDiff?.length && resultLine;
+          // A completed child can leave a real, declared-target diff while its
+          // final screen omits RESULT. The measured diff is sufficient to enter
+          // review/gate; a failed child or an unmeasured/empty diff still stops.
+          const succeeded = impl.ok && !!targetDiff?.length;
           goalOnlyReworkExhausted = !succeeded;
           observe('implementation-goal-only-rework', {
             status: succeeded ? 'succeeded' : 'exhausted', round: retryRound, targets,
             firstToolCalls, retryToolCalls: impl.toolCalls ?? null,
             targetDiffCount: targetDiff?.length ?? null, diffMeasured: after !== undefined, resultLine,
+            ...(succeeded ? { evidenceBasis: resultLine ? 'result-and-target-diff' : 'declared-target-diff' } : {}),
           }, succeeded ? {} : { level: 'warn' });
           if (!succeeded) impl = { ...impl, ok: false, summary: `goal-only-rework-exhausted: ${impl.summary}` };
           round = retryRound;
@@ -7434,6 +7467,69 @@ async function runSelfImplementInner(
         impl = { ...impl, ok: true, completionDisposition: undefined };
       }
     }
+    // ⭐ TDD 를 로직으로(S4) — 문면(device-first 조각 계획)이 아니라 실행 판정으로 끼운다.
+    //   ① 자식의 [tdd-red]/[tdd-green] 기록을 태그·같은 명령·결과로 판정한다.
+    //   ② 첫 조각 커밋의 피처 시험·구현 전 실행 RED 기록과 구현 뒤 같은 명령 GREEN 기록이
+    //     없으면 수리 라운드 1회(완료 경계·기존 동작은 보존), 그래도 없으면 fail-closed.
+    //   ③ 관측 원장에 tdd-red/tdd-green 이벤트를 남긴다.
+    let tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(impl.evidenceTranscript?.trim() || impl.summary));
+    if (tddJudgment.needsRepair && impl.ok && round < effectiveMax && opts.goalFile
+      && !hasCurrentProviderError() && !hasCurrentCredentialFailure()) {
+      let goalDocument: string | undefined;
+      try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { goalDocument = undefined; }
+      if (goalDocument !== undefined) {
+        const tddRetryNote = [
+          '[구현 재작업 · tdd-evidence-missing]',
+          `대상 경로: ${declaredPathsFromGoalDocumentText(goalDocument).paths.join(' · ') || '골 문서에 선언된 대상 경로 없음'}`,
+          '첫 조각 커밋에 피처 시험을 먼저 쓰고 구현 전 실행 RED 기록을 남기고, 구현 뒤 같은 명령의 GREEN 기록을 남겨라.',
+          "기록 양식(두 줄씩): 'EVIDENCE: [tdd-red] <무엇을 확인했나> || <증거 명령>' 다음 줄 'RESULT: <실패 요약 한 줄>' ·",
+          "'EVIDENCE: [tdd-green] <무엇을 확인했나> || <같은 증거 명령>' 다음 줄 'RESULT: <통과 요약 한 줄>'.",
+          `지금 잡힌 결손: ${tddJudgment.missing.join(' · ')}`,
+          '원래 골 문서(완료 경계 포함):',
+          goalDocument,
+        ].join('\n');
+        const tddRetryRound = round + 1;
+        observe('implementation-tdd-rework', { status: 'started', round: tddRetryRound, missing: [...tddJudgment.missing] }, { level: 'warn' });
+        progress('implementing', `[구현 재작업 · tdd-evidence-missing] 수리 라운드 ${tddRetryRound} 시작 — RED/GREEN 기록 결손`);
+        onNodeEntry(node('rework'), tddRetryRound);
+        onNodeEntry(node('implement'), tddRetryRound);
+        const tddRetryAbort = new AbortController();
+        const beforeTddRetry = impl;
+        let tddRetryImpl = impl;
+        try {
+          tddRetryImpl = await stepTimeout(s.implement({
+            sessionId, cwd: wt.path, feature: `${feature}\n\n${tddRetryNote}`, runId, shardIdentity, signal: tddRetryAbort.signal,
+            ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
+            onSurfaceProgress: (line) => progress('implementing', line.trimEnd()),
+            roundContext: { round: tddRetryRound, effectiveMax, previousRoundFailure: tddRetryNote },
+            ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+            ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
+          }), T.implement, 'implement');
+        } catch (error) {
+          tddRetryAbort.abort();
+          tddRetryImpl = { ...beforeTddRetry, ok: false, summary: `[구현 재작업 · tdd-evidence-missing] 수리 라운드 실패 — ${safeErrorDescription(error)}` };
+        }
+        const tddRetryJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddRetryImpl.evidenceTranscript?.trim() || tddRetryImpl.summary));
+        if (tddRetryImpl.ok && !tddRetryJudgment.needsRepair) {
+          observe('implementation-tdd-rework', { status: 'succeeded', round: tddRetryRound, missing: [] });
+          tddJudgment = tddRetryJudgment;
+          impl = tddRetryImpl;
+          round = tddRetryRound;
+        } else {
+          observe('implementation-tdd-rework', { status: 'exhausted', round: tddRetryRound, missing: [...tddRetryJudgment.missing] }, { level: 'warn' });
+          impl = { ...beforeTddRetry, ok: false, summary: `[구현 재작업 · tdd-evidence-missing] RED/GREEN 기록 결손 — ${beforeTddRetry.summary}` };
+        }
+      }
+    }
+    observe('tdd-red', {
+      round, planned: tddJudgment.planned, observed: tddJudgment.red.observed, missing: tddJudgment.red.observed ? [] : ['tdd-red'],
+      verify: tddJudgment.red.verify ?? null, result: tddJudgment.red.result ?? null,
+    }, tddJudgment.planned && !tddJudgment.red.observed ? { level: 'warn' } : {});
+    observe('tdd-green', {
+      round, planned: tddJudgment.planned, observed: tddJudgment.green.observed, sameCommand: tddJudgment.sameCommand,
+      missing: tddJudgment.green.observed && tddJudgment.sameCommand ? [] : ['tdd-green'],
+      verify: tddJudgment.green.verify ?? null, result: tddJudgment.green.result ?? null,
+    }, tddJudgment.planned && !(tddJudgment.green.observed && tddJudgment.sameCommand) ? { level: 'warn' } : {});
     // 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;
@@ -7546,6 +7642,7 @@ async function runSelfImplementInner(
       catch { /* observation is fail-soft */ }
     }
     const evidenceChecks = runBudgetedEvidenceChecks(roundGoal, wt.path, runId, evidenceHead);
+    const authoredSignal = authoredSignalExecution(roundGoal, evidenceChecks);
     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 });
@@ -8141,15 +8238,17 @@ async function runSelfImplementInner(
         let goalSlotFill: SupervisorGoalFillResult = 'unverifiable';
         let goalSlotDeficit: import('./goal-supervisor-fill.js').SupervisorGoalDeficit | undefined;
         let goalSlotAction: 'remeasure' | 'connect-goal' | undefined;
+        let goalSlotFillError = false;
         try {
           goalSlotFill = await fillUnverifiableGoalSlots({
-            path: opts.goalFile, round, gate, review,
+            path: opts.goalFile, round, gate, review, ...(authoredSignal ? { authoredSignal } : {}),
             ...(goalWiring ? { wiring: goalWiring } : {}),
             independentlyCheck: s.independentlyCheckGoalSlots ?? (async () => false),
             observeDeficit: (deficit) => { goalSlotDeficit = deficit; },
           });
         } catch {
           goalSlotFill = 'rejected';
+          goalSlotFillError = true;
         }
         if (goalSlotFill === 'not-applicable') {
           observe('goal-slot-remeasure-result', { round, result: goalSlotFill, gatePassed: gate.passed,
@@ -8173,7 +8272,7 @@ async function runSelfImplementInner(
           gate = measuredGate;
           let remeasureDeficit: import('./goal-supervisor-fill.js').SupervisorGoalDeficit | undefined;
           if (gate.passed) {
-            goalSlotFill = await fillUnverifiableGoalSlots({ path: opts.goalFile, round, gate, review,
+            goalSlotFill = await fillUnverifiableGoalSlots({ path: opts.goalFile, round, gate, review, ...(authoredSignal ? { authoredSignal } : {}),
               independentlyCheck: s.independentlyCheckGoalSlots ?? (async () => false),
               observeDeficit: (deficit) => { remeasureDeficit = deficit; } });
           }
@@ -8181,8 +8280,27 @@ async function runSelfImplementInner(
             gatePassed: measuredGate.passed,
             ...(remeasureDeficit ? { deficitKind: remeasureDeficit.kind,
               deficitEvidenceId: remeasureDeficit.evidenceId, gateLog: remeasureDeficit.gateLog,
-              reason: remeasureDeficit.reason, inputSummary: remeasureDeficit.inputSummary, gateLogRef: remeasureDeficit.gateLogRef } : {}) });
-          if (!gate.passed || goalSlotFill === 'unverifiable' || goalSlotFill === 'rejected') {
+              reason: remeasureDeficit.reason, reasonDetail: remeasureDeficit.reasonDetail,
+              inputSummary: remeasureDeficit.inputSummary, gateLogRef: remeasureDeficit.gateLogRef } : {}) });
+          if (goalSlotFill === 'unverifiable' && gate.passed) {
+            finalizeSupervisorDeliveries('goal-slot-remeasurement-unverifiable');
+            const evidenceReason = [remeasureDeficit?.reason, remeasureDeficit?.reasonDetail]
+              .filter((part): part is string => Boolean(part)).join(' · ');
+            const reason = `goal-slot remeasurement remained unverifiable after the second gate passed · evidence ${goalSlotDeficit.evidenceId}${evidenceReason ? ` · ${evidenceReason}` : ''}`;
+            observe('goal-slot-remeasurement-preserved', {
+              round, evidenceId: goalSlotDeficit.evidenceId, gatePassed: true,
+              reason: remeasureDeficit?.reason ?? 'remeasurement-deficit-not-reported',
+              ...(remeasureDeficit?.reasonDetail ? { reasonDetail: remeasureDeficit.reasonDetail } : {}),
+              ...(remeasureDeficit?.gateLogRef ? { gateLogRef: remeasureDeficit.gateLogRef } : {}),
+              disposition: 'preserve-for-recovery',
+            });
+            const pr = await preserveBlockedArtifacts({ stage: 'review-blocked', reason, gate, salvageStatusExpected: false });
+            return { ok: false, stage: 'review-blocked', node: 'rework', ...resolveRunOutcome({ termination: 'budget-exhausted' }),
+              sessionId, worktreePath: wt.path, branch: wt.branch, gate,
+              quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(),
+              ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
+          }
+          if (!gate.passed || goalSlotFill === 'rejected') {
             finalizeSupervisorDeliveries('goal-slot-remeasure-gate-failed');
             const reason = `goal-slot remeasurement ${!gate.passed ? 'failed' : goalSlotFill === 'rejected' ? 'rejected' : 'unmeasured'} · evidence ${goalSlotDeficit.evidenceId}`;
             const pr = await preserveBlockedArtifacts({ stage: 'gate-failed', reason, gate, salvageStatusExpected: false });
@@ -8193,7 +8311,10 @@ async function runSelfImplementInner(
           }
         }
         observe('goal-slot-fill', { round, result: goalSlotFill, gatePassed: gate.passed, reviewVerdict: review.verdict,
-          ...(goalSlotFill === 'unverifiable' && goalSlotDeficit ? { reason: goalSlotDeficit.reason, inputSummary: goalSlotDeficit.inputSummary, gateLogRef: goalSlotDeficit.gateLogRef } : {}),
+          ...(goalSlotDeficit ? { reason: goalSlotDeficit.reason, reasonDetail: goalSlotDeficit.reasonDetail,
+            inputSummary: goalSlotDeficit.inputSummary, gateLogRef: goalSlotDeficit.gateLogRef } : {}),
+          ...(!goalSlotDeficit && goalSlotFill === 'unverifiable' ? { reason: 'goal-slot-fill-no-deficit' } : {}),
+          ...(goalSlotFillError ? { reason: 'goal-slot-fill-error' } : {}),
           ...(goalSlotFill === 'not-applicable' ? { reason: 'test-step-scope-skipped', scopeReason: gate.scopeReason,
             testStepExecuted: gate.testStepExecuted } : {}) });
         if (goalSlotAction === 'connect-goal' && goalSlotDeficit) {
@@ -9003,9 +9124,9 @@ async function runSelfImplementInner(
       const mergedBase = m.baseRefName?.trim() || observedPrBase;
       if (mergedBase && displayBranchName(mergedBase) === 'main') {
         try {
-          const { syncMergedPrChecklist } = await import('../release-loop/merged-pr-checklist.js');
+          const { syncMergedPrChecklistWithFeedback } = await import('../release-loop/merged-pr-checklist.js');
           const goalFile = opts.goalFile ?? (opts.goalId ? s.goalDocumentPathByGoalId?.(opts.goalId) : undefined);
-          syncMergedPrChecklist(pr.number, wt.path, goalFile);
+          await syncMergedPrChecklistWithFeedback(pr.number, wt.path, goalFile);
         } catch (error) {
           observe('merged-pr-checklist-sync-failed', { number: pr.number, error: safeErrorDescription(error) }, { level: 'warn' });
         }
@@ -9042,7 +9163,7 @@ async function runSelfImplementInner(
       await withJourneyNode('cleanup', { provenance: 'post-merge', runId }, () => runPostMergeCleanup(s.postMergeCleanup, wt.path, wt.branch, opts.goalFile, mergedBase && defaultBranch && displayBranchName(mergedBase) === displayBranchName(defaultBranch) ? defaultBranch : undefined, (event, data) => {
         if (event.startsWith('post-merge-cleanup-')) cleanupOutcome = event.slice('post-merge-cleanup-'.length);
         observe(event, data);
-      }));
+      }, wt.inPlace === true));
       exitJourneyNode('cleanup', { provenance: 'post-merge', runId, outcome: cleanupOutcome });
       const mergedLedger = (() => {
         try { return loadRunLedger(runId); } catch { return null; }

package/src/self-implement/pod-inplace-worktree.ts

@@ -0,0 +1,82 @@
+import { realpathSync } from 'node:fs';
+import { relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+import { runGitCommand } from '../git-fs/runner.js';
+import { DEFAULT_BRANCH_WORKTREE_BASE, prepareWorktreeDependencies, resolveDefaultBranchBase, worktreeDependenciesAvailable } from '../git-fs/worktree.js';
+import type { CreateWorktreeResult } from '../git-fs/worktree.js';
+
+export type PodInplaceWorktree = CreateWorktreeResult & { readonly inPlace: true };
+
+export function tryCreatePodInplaceWorktree(input: {
+  readonly repoRoot: string;
+  readonly cwd: string;
+  readonly branch: string;
+  readonly base?: string;
+  readonly runId?: string;
+  readonly goalFile?: string;
+  readonly env: NodeJS.ProcessEnv;
+  readonly dependencyFallbackRoot?: string;
+}): PodInplaceWorktree | null {
+  if (input.env.ELANOUS_POD_INPLACE_WORKTREE !== '1') return null;
+  const skip = (reason: string): null => {
+    debug.log('self-implement', 'pod-inplace-worktree-skipped', { reason, branch: input.branch }, { level: 'warn' });
+    process.stderr.write(`ELANOUS_POD_INPLACE_SKIP reason=${reason}\n`);
+    return null;
+  };
+  if (input.env.ELANOUS_SUBSTRATE !== 'pod' || input.env.ELANOUS_POD_SINGLE_CHILD !== '1'
+    || !input.env.ELANOUS_POD_NAME?.trim() || !input.runId || input.env.ELANOUS_RUN_ID !== input.runId) {
+    return skip('not-single-owned-pod-child');
+  }
+  let repoRoot: string;
+  try {
+    repoRoot = realpathSync(input.repoRoot);
+    if (repoRoot !== realpathSync(input.cwd)) return skip('different-cwd');
+  } catch { return skip('repo-path-unavailable'); }
+  const git = (args: string[]) => runGitCommand(repoRoot, args, { encoding: 'utf8', timeout: 10_000 });
+  const top = git(['rev-parse', '--show-toplevel']);
+  if (top.status !== 0 || resolve(top.stdout.trim()) !== repoRoot) return skip('not-repo-root');
+  const head = git(['rev-parse', '--verify', 'HEAD']);
+  const resolvedBase = head.status === 0 ? head.stdout.trim() : '';
+  if (!/^[0-9a-f]{40,64}$/i.test(resolvedBase)) return skip('head-unavailable');
+  const base = input.base === DEFAULT_BRANCH_WORKTREE_BASE
+    ? (resolveDefaultBranchBase(repoRoot) ?? 'HEAD')
+    : (input.base ?? 'origin/main');
+  const pin = git(['rev-parse', '--verify', `${base}^{commit}`]);
+  if (pin.status !== 0 || pin.stdout.trim() !== resolvedBase) return skip('base-pin-mismatch');
+  const clean = git(['status', '--porcelain', '-z', '--untracked-files=all']);
+  let expectedGoalStatus: string | undefined;
+  if (input.goalFile) {
+    try {
+      const goalRelative = relative(repoRoot, realpathSync(resolve(repoRoot, input.goalFile))).split(sep).join('/');
+      if (/^docs\/goals\/GOAL-[^/]+\.md$/.test(goalRelative)) expectedGoalStatus = `?? ${goalRelative}`;
+    } catch { /* An unavailable goal file cannot exempt source dirt. */ }
+  }
+  const dirty = clean.stdout.split('\0').filter(Boolean);
+  if (clean.status !== 0 || (dirty.length > 0 && (dirty.length !== 1 || dirty[0] !== expectedGoalStatus))) return skip('source-dirty');
+  if (!worktreeDependenciesAvailable(repoRoot, input.dependencyFallbackRoot)) return skip('dependencies-unavailable');
+  const validBranch = git(['check-ref-format', '--branch', input.branch]);
+  if (validBranch.status !== 0) return skip('invalid-branch');
+  const held = git(['show-ref', '--verify', '--quiet', `refs/heads/${input.branch}`]);
+  if (held.status !== 1) return skip('branch-exists-or-unreadable');
+  const started = Date.now();
+  const switched = git(['switch', '--no-guess', '-c', input.branch]);
+  if (switched.status !== 0) {
+    throw new Error(`pod in-place branch switch failed: ${(switched.stderr || switched.stdout || `git exited ${switched.status}`).trim()}`);
+  }
+  const after = git(['rev-parse', '--verify', 'HEAD']);
+  const currentBranch = git(['branch', '--show-current']);
+  if (after.status !== 0 || after.stdout.trim() !== resolvedBase
+    || currentBranch.status !== 0 || currentBranch.stdout.trim() !== input.branch) {
+    throw new Error('pod in-place branch switch changed pin or branch unexpectedly');
+  }
+  const switchElapsedMs = Date.now() - started;
+  prepareWorktreeDependencies(repoRoot, repoRoot,
+    input.dependencyFallbackRoot ? { dependencyFallbackRoot: input.dependencyFallbackRoot } : {}, {});
+  const elapsedMs = Date.now() - started;
+  debug.log('self-implement', 'pod-inplace-worktree-selected', {
+    branch: input.branch, runId: input.runId, sourcePath: repoRoot,
+    resolvedBase, elapsedMs, switchElapsedMs, checkoutFiles: 0,
+  });
+  process.stderr.write(`ELANOUS_POD_INPLACE_SELECTED elapsedMs=${elapsedMs} switchMs=${switchElapsedMs} checkoutFiles=0\n`);
+  return { path: repoRoot, branch: input.branch, base: input.base ?? 'HEAD', resolvedBase, baseFreshness: 'head', inPlace: true };
+}

package/src/self-implement/pod-warm-pool-profile.ts

@@ -3,8 +3,8 @@ export const WARM_POOL_PROFILES = ['fixed', 'gate', 'landing', 'feature'] as con
 export type WarmPoolProfile = (typeof WARM_POOL_PROFILES)[number];
 export type WarmPoolTier = 'lite' | 'standard';
 const STANDARD_HOST_MAX: Readonly<Record<string, number>> = {
-  node-b: 16,
-  node-c: 4,
+  'node-b': 16,
+  'node-c': 4,
   'elangram-wsl': 5,
   'host-e-wsl': 5,
 };

package/src/self-implement/premise-review.ts

@@ -42,6 +42,11 @@ function latestFailingIds(input: FlexSignalsInput): readonly string[] | undefine
   return latest !== undefined && latest.length > 0 ? latest : undefined;
 }
 
+/** P2 evidence may name a file only when the latest failure ID itself confirms that attribution. */
+function latestPreexistingFailureId(input: FlexSignalsInput): string | undefined {
+  return latestFailingIds(input)?.find((id) => /\(preexisting\)\s*$/.test(id));
+}
+
 /**
  * 게이트 실패 id — 생산자(orchestrator 의 roundSummaryEntries.failedIds)와 P3 파서가 «같은 꼴»을 쓰도록
  * 둘 다 이 함수 짝을 거친다. 꼴: `${name}@${file ?? '?'} (${attribution})`.
@@ -96,11 +101,8 @@ function judgeP2(input: PremiseReviewInput): PremiseFinding {
   }
   const preexistingIndex = attributions.indexOf('preexisting');
   if (preexistingIndex >= 0) {
-    const latest = latestFailingIds(input);
-    const evidence = latest !== undefined && preexistingIndex < latest.length
-      ? latest[preexistingIndex]!
-      : 'preexisting';
-    return { premise: 'P2', verdict: 'wrong', evidence };
+    const latestPreexistingId = latestPreexistingFailureId(input);
+    return { premise: 'P2', verdict: 'wrong', evidence: latestPreexistingId ?? 'preexisting' };
   }
   if (attributions.includes('unknown')) {
     return { premise: 'P2', verdict: 'unknown', evidence: UNMEASURED };