elanous 0.2.37 → 0.2.40

package/src/self-dev/decompose.ts

@@ -442,6 +442,24 @@ function isRawSubtask(value: unknown): value is RawSubtask {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function ensureSingleCompletionCriterion(feature: string, targetPaths: string[]): string {
+  const lines = feature.split(/\r?\n/);
+  const criteria = lines.filter((line) => /^\s*완료 기준\s*:/.test(line));
+  if (criteria.length === 0) {
+    return `${feature}\n완료 기준: ${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  }
+  if (criteria.length === 1 && criteria[0]!.trim().length > '완료 기준:'.length) return feature;
+  const criterionText = criteria
+    .map((line) => line.replace(/^\s*완료 기준\s*:\s*/, '').trim())
+    .filter(Boolean)
+    .join(' · ');
+  const normalizedCriterion = criterionText || `${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  const firstCriterionIndex = lines.findIndex((line) => /^\s*완료 기준\s*:/.test(line));
+  const withoutCriteria = lines.filter((line) => !/^\s*완료 기준\s*:/.test(line));
+  withoutCriteria.splice(Math.min(firstCriterionIndex, withoutCriteria.length), 0, `완료 기준: ${normalizedCriterion}`);
+  return withoutCriteria.join('\n');
+}
+
 /**
  * G6 (1c) — 결정론적 hotPaths 추론. 분해된 sub-goal 의 feature 텍스트에서 repo 파일
  * 경로(src/…·docs/…·scripts/… + 확장자)를 뽑는다. LLM 이 hotPaths 를 안 채워도 hot-file
@@ -476,7 +494,8 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
         ? own[index]!
         : (goal.hotPaths ?? []).filter((path) => parentTargets.includes(path)));
       const claimedOwners = parentTargets.map((path) => goals.flatMap((_, index) => claims[index]!.includes(path) ? [index] : []));
-      const conflictingClaims = claimedOwners.some((indices) => indices.length > 1);
+      const sharedExplicitTarget = own.length === 2 && own[0]!.some((path) => own[1]!.includes(path));
+      const conflictingClaims = sharedExplicitTarget || claimedOwners.some((indices) => indices.length > 1);
       const nameOwners = parentTargets.map((path) => {
         const stemWords = path.split('/').at(-1)!.replace(/\.[^.]+$/, '').toLowerCase().match(/[a-z0-9]+/g) ?? [];
         if (!stemWords.length || stemWords.join('').length < 4) return [];
@@ -507,24 +526,41 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
       // A named path wins over model order; if every path points at one child,
       // keep the old scope rather than inventing work for the other child.
       const partitions = goals.map((_, index) => parentTargets.filter((_, pathIndex) => owners[pathIndex] === index));
-      const sharedOtherPaths = (goals[0]?.hotPaths ?? []).some((path) =>
-        !parentTargets.includes(path) && (goals[1]?.hotPaths ?? []).includes(path));
       const conflictingParentReference = goals.some((goal, index) =>
         own[index]!.length > 0 && (goal.hotPaths ?? []).some((path) =>
           parentTargets.includes(path) && !own[index]!.includes(path)));
       if (partitions.every((paths) => paths.length > 0)
         && !conflictingClaims && !ambiguousName && !conflictingNameClaim && !conflictingUnclaimedHint
-        && !sharedOtherPaths && !conflictingParentReference) return goals.map((goal, index) => {
+        && !conflictingParentReference) return goals.map((goal, index) => {
         const targets = partitions[index]!;
-        return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...targets])],
-          feature: `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}\n완료 기준: ${targets.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.` };
+        // A declared child target may add a helper outside the parent fence. Bare
+        // hotPaths outside that fence are references, so do not widen the write fence.
+        const explicitHelpers = own[index]!.filter((path) => !parentTargets.includes(path));
+        const feature = `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}`;
+        return { ...goal, hotPaths: [...new Set([...targets, ...explicitHelpers])],
+          feature: ensureSingleCompletionCriterion(feature, targets) };
       });
     }
   }
-  return goals.map((goal) => {
+  const explicitChildTargets = goals.map((goal) => declaredTargets(goal.feature ?? ''));
+  const explicitParentTargets = explicitChildTargets.map((paths) => paths.filter((path) => parentTargets.includes(path)));
+  const explicitTargetsArePartition = goals.length === 2
+    && explicitParentTargets.every((paths) => paths.length > 0)
+    && new Set(explicitChildTargets.flat()).size === explicitChildTargets.flat().length
+    && explicitParentTargets[0]!.every((path) => !explicitParentTargets[1]!.includes(path))
+    && new Set(explicitParentTargets.flat()).size === parentTargets.length
+    && parentTargets.every((path) => explicitParentTargets.flat().includes(path))
+    && goals.every((goal, index) => (goal.hotPaths ?? []).every((path) =>
+      !parentTargets.includes(path) || explicitChildTargets[index]!.includes(path)));
+  return goals.map((goal, index) => {
     // hotPaths also contains inferred references; only an explicit target line establishes child scope.
-    const own = declaredTargets(goal.feature ?? '');
-    if (own.length) return goal;
+    const own = explicitChildTargets[index]!;
+    if (own.length) {
+      if (explicitTargetsArePartition) {
+        return { ...goal, hotPaths: own, feature: ensureSingleCompletionCriterion(goal.feature ?? '', own) };
+      }
+      return goal;
+    }
     return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...parentTargets])],
       feature: `${goal.feature}\n대상 경로: ${parentTargets.join(' · ')}` };
   });

package/src/self-dev/dev-cli.ts

@@ -1113,6 +1113,8 @@ export async function executeDevSelfRun(
     }
     await superviseRun({
       initial: [initialJob],
+      // Pod worktree paths are not necessarily mounted in this parent process.
+      knowhowRepo: process.cwd(),
       // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
       // authored goal as its feature). Without that executor the rerun could only replay the same goal — declare false.
       repairGoalExecution: supervise.executePiece !== undefined,

package/src/self-dev/dev-pipeline.ts

@@ -709,16 +709,16 @@ export function buildAgentMissionDevSpec(o: {
 export async function executeAgentMissionReroute(
   spec: DevPipelineSpec,
   agentBackend: AgentBackend,
-  deps?: { runDevPipeline?: typeof runDevPipeline },
+  deps?: { runDevPipeline?: typeof runDevPipeline; signal?: AbortSignal },
 ): Promise<{ result: AgentMissionResult; exitCode: number }> {
   const run = deps?.runDevPipeline ?? runDevPipeline;
-  const r = await run(spec, { resolveBackend: () => agentBackend });
+  const r = await run(spec, { resolveBackend: () => agentBackend, ...(deps?.signal ? { signal: deps.signal } : {}) });
   // ★ 잘못된 라우팅 즉시 표면화 — spec 이 external+pty 가 아니면 kind 불일치(무조건 캐스팅 금지).
   if (r.kind !== 'agent-mission') {
     throw new DevPipelineError(`executeAgentMissionReroute: 예상 밖 dispatch(kind=${r.kind}) — external+pty spec 이어야`);
   }
   const result = r.result;
-  return { result, exitCode: result.ok ? 0 : 2 };
+  return { result, exitCode: result.reason === 'aborted' ? 130 : result.ok ? 0 : 2 };
 }
 
 // ── U4b: self implement 재라우팅 seam(테스트 가능) ──
@@ -2234,6 +2234,7 @@ async function runDevPipelineDispatch(
     const result = await run({
       ...toSelfImplementOptions(text, plan, seams),
       ...(spec.runId ? { runId: spec.runId } : {}),
+      ...(deps.signal ? { signal: deps.signal } : {}),
       onNodeEntry: (node, round) => { walk.push({ node, round }); },
     });
     // ⛔ 「걸음이 비었다」와 「안 걸었다」를 가른다 — 빈 배열은 «싣지 않는다».
@@ -2252,5 +2253,8 @@ async function runDevPipelineDispatch(
   // agent-mission-pty
   const run = deps.runAgentMission ?? (await import('../agent-mission/driver.js')).runAgentMission;
   const resolveBackend = deps.resolveBackend ?? (await import('../agent-mission/driver.js')).resolveBackend;
-  return { plan, kind: 'agent-mission', result: await run(toAgentMissionSpec(text, plan, resolveBackend)) };
+  return { plan, kind: 'agent-mission', result: await run({
+    ...toAgentMissionSpec(text, plan, resolveBackend),
+    ...(deps.signal ? { signal: deps.signal } : {}),
+  }) };
 }

package/src/self-dev/draft-residue.ts

@@ -126,6 +126,8 @@ export interface DraftResidueAdapters {
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void> | void;
   comment(repository: string, number: number, body: string): Promise<void> | void;
   closePr(repository: string, number: number): Promise<void> | void;
+  /** Persist the existing `수확보류: harvest-deferred` PR-body marker after a verified close. */
+  editBody(repository: string, number: number, body: string): Promise<void> | void;
   /** Undefined means liveness could not be established, not that no branch is live. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined> | ReadonlySet<string> | undefined;
   /** Undefined means the prior run could not be identified as ended. */
@@ -133,11 +135,22 @@ export interface DraftResidueAdapters {
 }
 /** One close budget shared by every terminal replayed in a tick and the draft sweep that follows. */
 export interface DraftCloseBudget { remaining: number }
+export type HarvestExistingPr = { number: number; url?: string; labels?: readonly string[] };
+/** Injectable remote-branch / same-branch-PR / draft-create seams for timed-out-harvestable. */
+export interface HarvestableDraftAdapters {
+  /** Override host repository for harvest lookups and creates. */
+  repository?: string;
+  remoteBranchExists(repository: string, branch: string): Promise<boolean | undefined> | boolean | undefined;
+  findExistingPr(repository: string, branch: string): Promise<HarvestExistingPr | null | undefined> | HarvestExistingPr | null | undefined;
+  createDraftPr(repository: string, branch: string): Promise<HarvestExistingPr> | HarvestExistingPr;
+  addHarvestableLabel(repository: string, number: number): Promise<void> | void;
+}
 export interface DraftResidueContext {
   ledgerRunId: string;
   ledgerDir: string;
   adapters?: DraftResidueAdapters;
   closeBudget?: DraftCloseBudget;
+  harvest?: HarvestableDraftAdapters;
 }
 export type DraftResidueResult = { status: 'recorded' | 'skipped' | 'failed'; reason?: string; step?: string };
 
@@ -253,6 +266,7 @@ export function defaultAdapters(sources: ResidueRunStatusSources = defaultRunSta
     },
     comment: (repository, number, body) => { gh(['pr', 'comment', String(number), '-R', repository, '--body', body]); },
     closePr: (repository, number) => { gh(['pr', 'close', String(number), '-R', repository]); },
+    editBody: (repository, number, body) => { gh(['pr', 'edit', String(number), '-R', repository, '--body', body]); },
     listLiveBranches: (repository) => {
       if (repository.toLowerCase() !== hostRepository()?.toLowerCase()) return undefined;
       const root = findGitDir(process.cwd())?.root;
@@ -297,6 +311,117 @@ function hostRepository(): string | null {
   return match?.[1] ?? null;
 }
 
+function harvestBranchOk(branch: string): boolean {
+  return /^[A-Za-z0-9._/-]+$/.test(branch) && !branch.includes('..');
+}
+
+/** Production harvest seams: remote branch via `git ls-remote --exit-code`, same-branch PR via `gh pr list --head`, draft via `gh pr create --draft`. */
+export function defaultHarvestAdapters(record?: PrTerminalRecord): HarvestableDraftAdapters {
+  return {
+    remoteBranchExists: (repository, branch) => {
+      if (!harvestBranchOk(branch) || !/^[\w.-]+\/[\w.-]+$/.test(repository)) return undefined;
+      const root = findGitDir(process.cwd())?.root;
+      const remote = `https://github.com/${repository}.git`;
+      const result = spawnSync('git', ['ls-remote', '--exit-code', remote, `refs/heads/${branch}`], {
+        cwd: root ?? process.cwd(), encoding: 'utf8', timeout: 10_000,
+      });
+      if (result.status === 0) return true;
+      if (result.status === 2) return false;
+      return undefined;
+    },
+    findExistingPr: (repository, branch) => {
+      if (!harvestBranchOk(branch) || !/^[\w.-]+\/[\w.-]+$/.test(repository)) return undefined;
+      try {
+        const rows: unknown = JSON.parse(gh(['pr', 'list', '-R', repository, '--state', 'open', '--head', branch,
+          '--json', 'number,url,labels,headRefName', '--limit', '100']));
+        if (!Array.isArray(rows)) return undefined;
+        const matching = rows.filter((row): row is { number: number; url?: string; headRefName: string; labels?: Array<{ name: string } | string> } =>
+          !!row && typeof row === 'object' && typeof (row as { headRefName?: unknown }).headRefName === 'string'
+          && (row as { headRefName: string }).headRefName === branch
+          && typeof (row as { number?: unknown }).number === 'number'
+          && Number.isSafeInteger((row as { number: number }).number) && (row as { number: number }).number > 0);
+        if (matching.length === 0) return null;
+        if (matching.length !== 1) return undefined;
+        const row = matching[0]!;
+        const labels = (row.labels ?? []).map((label) => typeof label === 'string' ? label : label.name).filter((name): name is string => typeof name === 'string');
+        return { number: row.number, url: typeof row.url === 'string' ? row.url : undefined, labels };
+      } catch {
+        return undefined;
+      }
+    },
+    createDraftPr: (repository, branch) => {
+      const title = `Harvest timed-out ${record?.childRunId ?? branch}`;
+      const body = `Draft residue: timed-out-harvestable · owner=${record?.owner ?? 'unknown'}(${record?.ownerSource ?? 'unknown'}) · run=${record?.childRunId ?? 'unobserved'} · branch=${branch}`;
+      const out = gh(['pr', 'create', '-R', repository, '--head', branch, '--draft', '--title', title, '--body', body]);
+      const match = /https:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/.exec(out);
+      if (!match || match[1]!.toLowerCase() !== repository.toLowerCase()) throw new Error('draft-create-unobserved');
+      return { number: Number(match[2]), url: match[0] };
+    },
+    addHarvestableLabel: (repository, number) => { gh(['pr', 'edit', String(number), '-R', repository, '--add-label', harvestable]); },
+  };
+}
+
+/** Open one draft PR for a timed-out-harvestable terminal when the remote branch exists and no same-branch PR is open. */
+export async function harvestHarvestableDrafts(record: PrTerminalRecord, ctx: DraftResidueContext): Promise<DraftResidueResult> {
+  const adapters = ctx.adapters ?? defaultAdapters();
+  const harvest = ctx.harvest ?? defaultHarvestAdapters(record);
+  const fields = { childRunId: record.childRunId, prNumber: record.prNumber, terminalClass: record.terminalClass, owner: record.owner, ownerSource: record.ownerSource };
+  const log = (event: string, data: Record<string, unknown> = {}) => debug.log('draft.residue', event, { ...fields, ...data });
+  const skipped = (reason: string): DraftResidueResult => { log('skipped', { reason }); return { status: 'skipped', reason }; };
+  let step = 'ledger';
+  try {
+    if (record.terminalClass !== 'timed-out-harvestable') return skipped(record.terminalClass);
+    const branch = typeof record.branch === 'string' && record.branch.trim() ? record.branch.trim() : null;
+    if (!branch) return skipped('missing-branch');
+    const repository = harvest.repository ?? record.repository ?? hostRepository();
+    if (!repository) return skipped('host-repository-unobserved');
+    const ledger = adapters.loadLedger(ctx.ledgerRunId, ctx.ledgerDir);
+    if (ledger === undefined) throw new Error('Terminal ledger unavailable');
+    const rows = (ledger ?? []).filter((entry) => entry.data.childRunId === record.childRunId);
+    const completed = (effect: string, number: number): boolean => rows.some((entry) => entry.event === 'pr-terminal-effect'
+      && entry.data.effect === effect && entry.data.number === number);
+    const acknowledge = (effect: string, number: number): void => {
+      adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal-effect', data: { childRunId: record.childRunId, effect, number } }, ctx.ledgerDir);
+    };
+    if (completed('complete', 0) || completed('complete', record.prNumber ?? 0)) return skipped('already-recorded');
+    step = 'remote-branch';
+    const exists = await harvest.remoteBranchExists(repository, branch);
+    if (exists === undefined) throw new Error('Remote branch lookup unavailable');
+    if (exists === false) {
+      acknowledge('complete', 0);
+      return skipped('missing-branch');
+    }
+    step = 'find-existing-pr';
+    const existing = await harvest.findExistingPr(repository, branch);
+    if (existing === undefined) throw new Error('Existing PR lookup unavailable');
+    let pr = existing;
+    if (!pr) {
+      step = 'create-draft-pr';
+      pr = await harvest.createDraftPr(repository, branch);
+      log('harvest-created', { number: pr?.number, branch, repository });
+    } else {
+      log('harvest-reused', { number: pr.number, branch, repository });
+    }
+    if (!pr || !Number.isSafeInteger(pr.number) || pr.number <= 0) throw new Error('draft-create-unobserved');
+    if (!completed('harvestable', pr.number)) {
+      if (!pr.labels?.includes(harvestable)) {
+        step = 'add-label';
+        await harvest.addHarvestableLabel(repository, pr.number);
+        log('harvestable-labeled', { prNumber: pr.number });
+      }
+      step = 'ledger';
+      acknowledge('harvestable', pr.number);
+    }
+    step = 'ledger';
+    acknowledge('complete', 0);
+    return { status: 'recorded' };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    log('failed', { step, reason });
+    return { status: 'failed', step, reason };
+  }
+}
+
 export interface DraftResidueReplayOptions {
   repository?: string;
   ledgerDir?: string;
@@ -385,7 +510,11 @@ export async function replayPodTerminals(options: DraftResidueReplayOptions = {}
       const outcome = await applyPodTerminal(record, { ledgerDir, ledgerRunId, adapters: replayAdapters, closeBudget });
       if (outcome.status === 'recorded' || outcome.reason === 'already-recorded') recovered++;
       else if (outcome.status === 'skipped' && outcome.reason === 'repository-unobserved') unresolved++;
-      else if (outcome.status === 'skipped' && !['previous-run-unverified', 'previous-run-live', 'close-cap', 'host-repository-unobserved', 'restore-unverified'].includes(outcome.reason ?? '')) recovered++;
+      else if (outcome.status === 'skipped' && ![
+        'previous-run-unverified', 'previous-run-live', 'close-cap', 'host-repository-unobserved', 'restore-unverified',
+        'deferred-close-ownership-unverified', 'deferred-close-reopened', 'deferred-close-unverified',
+        'deferred-close-run-unverified', 'deferred-close-raced',
+      ].includes(outcome.reason ?? '')) recovered++;
       else pending++;
     }
   }
@@ -409,12 +538,34 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
     const acknowledge = (effect: string, number: number): void => {
       adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal-effect', data: { childRunId: record.childRunId, effect, number } }, ctx.ledgerDir);
     };
+    const markDeferredBody = async (number: number, expectedBranch: string): Promise<void> => {
+      if (record.terminalClass !== 'merge-ready-not-merged' || completed('harvest-deferred-body', number)) return;
+      const latest = await adapters.getPr(number);
+      if (!latest || latest.state !== 'CLOSED' || latest.headSha?.toLowerCase() !== record.headSha?.toLowerCase()
+        || latest.branch !== expectedBranch || typeof latest.body !== 'string') {
+        throw new Error('harvest-deferred-body-unverified');
+      }
+      const marker = '수확보류: harvest-deferred';
+      if (!latest.body.split(/\r?\n/).includes(marker)) {
+        step = 'edit-body';
+        await adapters.editBody(record.repository!, number, `${latest.body.trimEnd()}\n${marker}\n`);
+        const verified = await adapters.getPr(number);
+        if (!verified || verified.state !== 'CLOSED' || verified.headSha?.toLowerCase() !== record.headSha?.toLowerCase()
+          || verified.branch !== expectedBranch || !verified.body?.split(/\r?\n/).includes(marker)) {
+          throw new Error('harvest-deferred-body-unverified');
+        }
+      }
+      step = 'ledger';
+      acknowledge('harvest-deferred-body', number);
+    };
     if (completed('complete', record.prNumber ?? 0) || completed('protected', record.prNumber ?? 0)) return skipped('already-recorded');
     if (!rows.some((entry) => entry.event === 'pr-terminal')) {
       adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal', data: { ...record } }, ctx.ledgerDir);
       log('terminal-recorded');
     }
-    // AUT-TIMEOUT-NO-HARVEST 첫 조각은 «분류만» — 그 branch 로 PR 을 여는 효과는 다음 조각(원격 가지 존재·기존 PR 확인 관문과 함께).
+    if (record.terminalClass === 'timed-out-harvestable') {
+      return harvestHarvestableDrafts(record, { ...ctx, adapters, harvest: ctx.harvest ?? defaultHarvestAdapters(record) });
+    }
     if (record.terminalClass === 'failed-no-pr' || record.terminalClass === 'failed-pr-unobserved' || record.prNumber === null) {
       acknowledge('complete', 0);
       return skipped(record.terminalClass);
@@ -441,6 +592,21 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
     step = 'get-pr';
     const pr = await adapters.getPr(record.prNumber);
     if (!pr || pr.number !== record.prNumber || !Array.isArray(pr.labels) || !pr.branch || !Number.isFinite(Date.parse(pr.createdAt))) throw new Error('PR lookup unavailable');
+    const deferredCloseTerminal = record.terminalClass === 'failed-with-pr' || record.terminalClass === 'merge-ready-not-merged';
+    if (deferredCloseTerminal && completed('deferred-close', pr.number)) {
+      if (pr.state !== 'CLOSED' || !record.headSha
+        || pr.headSha?.toLowerCase() !== record.headSha.toLowerCase()
+        || (record.branch && pr.branch !== record.branch)) return skipped('deferred-close-reopened');
+      await markDeferredBody(pr.number, pr.branch);
+      step = 'ledger';
+      acknowledge('complete', pr.number);
+      return { status: 'recorded' };
+    }
+    // After a close intent without its receipt, GitHub cannot prove whether our close was applied and
+    // subsequently reversed by another owner. Leave that ambiguity for a human instead of closing again.
+    if (deferredCloseTerminal && completed('deferred-close-intent', pr.number)) {
+      return skipped('deferred-close-ownership-unverified');
+    }
     // Review r8: the PR may have merged or closed after this run's terminal — a failed terminal then writes nothing
     // (no harvestable label, no owner comment) and settles once.
     if (record.terminalClass !== 'landed' && pr.state !== undefined && pr.state !== 'OPEN') {
@@ -733,6 +899,59 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
     }
     if (deferred) return skipped('previous-run-unverified');
     if (capped) return skipped('close-cap');
+    if (deferredCloseTerminal) {
+      if (budget.remaining <= 0) return skipped('close-cap');
+      const restore = `Draft residue: harvest deferred · run=${record.childRunId} · head=${record.headSha} · branch=${pr.branch}. Close does not delete this ref; verify it before restore.${record.terminalClass === 'merge-ready-not-merged' ? ' 다시 여는 법: gh pr reopen + land-enqueue.' : ''}`;
+      step = 'get-pr';
+      const latest = await adapters.getPr(pr.number);
+      if (!latest || latest.state !== 'OPEN' || latest.isDraft !== true || !record.headSha
+        || latest.headSha?.toLowerCase() !== record.headSha.toLowerCase()
+        || latest.branch !== pr.branch || (record.branch && latest.branch !== record.branch)
+        || !Array.isArray(latest.labels) || latest.labels.some((label) => PROTECTED_LABELS.has(label) || label.includes('harvest-claimed'))) {
+        return skipped('deferred-close-unverified');
+      }
+      step = 'list-live-branches';
+      const activeBranches = await adapters.listLiveBranches(record.repository);
+      step = 'get-run-status';
+      const runStatus = await adapters.getRunStatus(latest, record.repository);
+      if (!activeBranches || activeBranches.has(latest.branch)
+        || !['completed', 'failed', 'cancelled', 'abandoned', 'self-implement.result final'].includes(runStatus ?? '')) {
+        return skipped('deferred-close-run-unverified');
+      }
+      step = 'list-comments';
+      const comments = await adapters.getAllComments?.(record.repository, pr.number);
+      if (!Array.isArray(comments) || comments.some((comment) => typeof comment !== 'string'
+        || /landing-verified\s*:|land-enqueue\s*:/i.test(comment))) return skipped('deferred-close-unverified');
+      if (!comments.includes(restore)) { step = 'comment'; await adapters.comment(record.repository, pr.number, restore); }
+      step = 'get-pr';
+      const beforeClose = await adapters.getPr(pr.number);
+      step = 'list-comments';
+      const commentsBeforeClose = await adapters.getAllComments?.(record.repository, pr.number);
+      step = 'list-live-branches';
+      const liveBeforeClose = await adapters.listLiveBranches(record.repository);
+      step = 'get-run-status';
+      const statusBeforeClose = await adapters.getRunStatus(latest, record.repository);
+      if (!beforeClose || beforeClose.state !== 'OPEN' || beforeClose.isDraft !== true
+        || beforeClose.headSha?.toLowerCase() !== record.headSha.toLowerCase()
+        || beforeClose.branch !== latest.branch || !Array.isArray(beforeClose.labels)
+        || beforeClose.labels.some((label) => PROTECTED_LABELS.has(label) || label.includes('harvest-claimed'))
+        || !Array.isArray(commentsBeforeClose) || !commentsBeforeClose.includes(restore)
+        || commentsBeforeClose.some((comment) => typeof comment !== 'string'
+          || /landing-verified\s*:|land-enqueue\s*:/i.test(comment))
+        || !liveBeforeClose || liveBeforeClose.has(latest.branch)
+        || !['completed', 'failed', 'cancelled', 'abandoned', 'self-implement.result final'].includes(statusBeforeClose ?? '')) {
+        return skipped('deferred-close-raced');
+      }
+      step = 'ledger';
+      acknowledge('deferred-close-intent', pr.number);
+      step = 'close-pr';
+      await adapters.closePr(record.repository, pr.number);
+      budget.remaining--;
+      step = 'ledger';
+      acknowledge('deferred-close', pr.number);
+      log('deferred-closed', { branch: latest.branch, headSha: record.headSha });
+      await markDeferredBody(pr.number, latest.branch);
+    }
     step = 'ledger';
     acknowledge('complete', record.prNumber);
     return { status: 'recorded' };

package/src/self-dev/draft-sweep.ts

@@ -938,25 +938,38 @@ async function applyDraftSweepPlan(repository: string, adapters: DraftSweepAdapt
     number, action, reason, ...(statusLabel ? { statusLabel } : {}), applied: false,
   })), counts: {}, closeCap: plan.closeCap, closeCapSource: plan.closeCapSource };
   const writable = plan.entries.filter((entry) => entry.action !== 'report' && (entry.action === 'close' || Boolean(entry.statusLabel)));
-  const preflightEntries = new Map(writable.map((entry) => [entry.number, entry]));
-  for (const entry of writable) if (entry.supersedeNewer) {
-    const newer = plan.entries.find((candidate) => candidate.number === entry.supersedeNewer!.number);
-    if (!newer) { result.error = `snapshot apply plan missing newer PR #${entry.supersedeNewer.number}`; return result; }
-    preflightEntries.set(newer.number, newer);
+  for (const entry of writable) if (entry.supersedeNewer && !plan.entries.some((candidate) => candidate.number === entry.supersedeNewer!.number)) {
+    result.error = `snapshot apply plan missing newer PR #${entry.supersedeNewer.number}`;
+    return result;
   }
   if (!adapters.getDraftSnapshot) { result.error = 'draft snapshot preflight unavailable'; return result; }
-  // Read and validate every target before the first mutation: one stale item blocks the whole write batch.
-  const snapshots = await mapBounded([...preflightEntries.values()], DRAFT_SWEEP_CONCURRENCY, async (entry) => ({ entry,
-    current: await adapters.getDraftSnapshot!(repository, entry.number) }));
-  const drift = snapshots.find(({ entry, current }) => !current || current.number !== entry.number || current.state !== 'open'
-    || current.draft !== true || current.headSha !== entry.headSha || current.branch !== entry.branch || current.updatedAt !== entry.updatedAt
-    || current.labels.length !== entry.labels.length || [...current.labels].sort().join('\0') !== [...entry.labels].sort().join('\0'));
-  if (drift) {
-    const number = drift.entry.number;
-    result.error = `draft snapshot drift at #${number}; no writes performed`;
-    for (const entry of result.entries) if (writable.some((item) => item.number === entry.number)) entry.error = result.error;
+  // The frozen classification is one transaction boundary: every plan row must still match before any write.
+  const snapshots = await mapBounded(plan.entries, DRAFT_SWEEP_CONCURRENCY, async (entry) => {
+    try { return { entry, current: await adapters.getDraftSnapshot!(repository, entry.number), lookupError: undefined as string | undefined }; }
+    catch (error) { return { entry, current: undefined, lookupError: sweepFailureReason(error) }; }
+  });
+  const drift = snapshots.flatMap(({ entry, current, lookupError }) => {
+    if (lookupError) return [{ number: entry.number, reason: `snapshot lookup failed: ${lookupError}` }];
+    if (!current) return [{ number: entry.number, reason: 'snapshot unavailable' }];
+    const reasons: string[] = [];
+    if (current.number !== entry.number) reasons.push('number drift');
+    if (current.state !== 'open' && current.state !== 'closed') reasons.push('invalid state');
+    else if (current.state !== 'open') reasons.push(`state drift: expected open, got ${current.state}`);
+    if (current.draft !== true) reasons.push('draft state drift');
+    if (typeof current.headSha !== 'string' || current.headSha !== entry.headSha) reasons.push('head SHA drift');
+    if (typeof current.branch !== 'string' || current.branch !== entry.branch) reasons.push('branch drift');
+    if (typeof current.updatedAt !== 'string' || current.updatedAt !== entry.updatedAt) reasons.push('updatedAt drift');
+    if (!Array.isArray(current.labels) || current.labels.some((name) => typeof name !== 'string')
+      || current.labels.length !== entry.labels.length || [...current.labels].sort().join('\0') !== [...entry.labels].sort().join('\0')) reasons.push('labels drift');
+    return reasons.map((reason) => ({ number: entry.number, reason }));
+  });
+  if (drift.length) {
+    result.error = `draft snapshot drift at ${drift.map(({ number, reason }) => `#${number} (${reason})`).join(', ')}; no writes performed`;
+    for (const item of drift) result.entries.find((entry) => entry.number === item.number)!.error = item.reason;
     return result;
   }
+  const writableNumbers = new Set(writable.map((entry) => entry.number));
+  const snapshotsForApply = snapshots.filter(({ entry }) => writableNumbers.has(entry.number));
   const stopPlans = writable.filter((entry) => entry.stopRunRequired === true);
   const stoppedRuns = new Set<number>();
   if (stopPlans.length) {
@@ -986,7 +999,7 @@ async function applyDraftSweepPlan(repository: string, adapters: DraftSweepAdapt
       } catch (error) { result.error = `could not stop planned run at #${check.entry.number}: ${sweepFailureReason(error)}`; return result; }
     }
   }
-  for (const { entry } of snapshots) {
+  for (const { entry } of snapshotsForApply) {
     const output = result.entries.find((item) => item.number === entry.number)!;
     let mutated = false;
     try {

package/src/self-dev/graph-journey-route.ts

@@ -122,6 +122,10 @@ export function readJourneyEdge(
  *  그 밖의 칸은 그 간선에 결속할 근거(예: 착지 거부 원문·cardId · LAND-REFUSAL-EDGES) — 간선 칸(from·to·taken…)을 덮지 못한다. */
 export interface JourneyEdgeFields {
   readonly moveId?: string;
+  readonly runId?: string;
+  readonly card?: string;
+  readonly pr?: number;
+  readonly head?: string;
   readonly [key: string]: unknown;
 }
 
@@ -140,11 +144,15 @@ export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: s
       graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
       ...journeyJoinFields(),
     });
-    // Evidence never overrides an edge field: the later spread wins, and `reason`/join keys are reserved.
-    const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch, ...evidence } = data ?? {};
+    // Evidence never overrides an edge field: the later spread wins. Explicit repair join keys win over ambient context.
+    const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch,
+      runId, card, pr, head, moveId, ...evidence } = data ?? {};
     debug.log('self-implement', 'graph-edge-taken', {
       ...evidence, graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
       ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
+      ...(runId === undefined ? {} : { runId }), ...(card === undefined ? {} : { card }),
+      ...(pr === undefined ? {} : { pr }), ...(head === undefined ? {} : { head }),
+      ...(moveId === undefined ? {} : { moveId }),
     });
   } catch { /* 관측은 fail-soft */ }
 }

package/src/self-dev/launch-preflight-text.ts

@@ -22,8 +22,8 @@ export interface LaunchPreflightBlocker {
   readonly name: string;
   /** 왜 막혔는지 한 줄 — 경로와 수를 포함한다. */
   readonly detail: string;
-  /** 골 판독 실패(`goal-unreadable`)와 traced-path 오류(`missing-traced-path`)를 가르는 사유 코드. */
-  readonly reasonCode?: 'goal-unreadable' | 'missing-traced-path';
+  /** 골 판독 실패(`goal-unreadable`) · 골 해석 실패(`goal-parse`) · traced-path 오류(`missing-traced-path`)를 가르는 사유 코드. */
+  readonly reasonCode?: 'goal-unreadable' | 'goal-parse' | 'missing-traced-path';
   /** 어느 검사인지 — 경로를 접지 않은 검사 이름. */
   readonly checkName?: string;
   /** 잘리지 않은 대상 경로. 경로 없는 검사(빈 traced paths)는 생략한다. */

package/src/self-dev/launch-preflight.ts

@@ -1112,14 +1112,31 @@ export function decideAskPreflight(
   const inspectionRoot = goalDocument === null || !hasAuthoredGoal
     ? undefined
     : opts.declaredPathsRoot?.trim() || process.cwd();
-  const authoredTracedPaths = goalDocument === null
-    ? []
-    : inspectableAuthoredTracedPaths(deps.tracedPaths(goalDocument), inspectionRoot);
+  // ⛔ 골 «판독»(읽기) 실패와 골 «해석» 실패는 고칠 곳이 다르다 — 파서가 던진 예외를 사유 코드로 바꿔
+  //   원장에 «어느 검사가» 막았는지 남긴다(AUT-PREFLIGHT-REASON-OPAQUE: 두 갈래가 한 문장으로 뭉개졌다).
+  let goalParseFailure: { readonly checkName: string; readonly message: string } | undefined;
+  const authoredTracedPaths = (() => {
+    if (goalDocument === null) return [];
+    try {
+      return inspectableAuthoredTracedPaths(deps.tracedPaths(goalDocument), inspectionRoot);
+    } catch (error) {
+      goalParseFailure = { checkName: 'goal-parse', message: oneLineConfidenceFailureDetail(error) };
+      return [];
+    }
+  })();
   const tracedPathsRaw = opts.pathsOverride ?? authoredTracedPaths;
   const tracedPaths = inspectionRoot && !opts.pathsOverride
     ? tracedPathsRaw.filter((path) => tracedPathExists(path, inspectionRoot) || isFileShapedTracedPath(path))
     : tracedPathsRaw;
-  const declaredNewPaths = goalDocument === null ? new Set<string>() : new Set(declaredNewFilePaths(goalDocument));
+  const declaredNewPaths = (() => {
+    if (goalDocument === null) return new Set<string>();
+    try {
+      return new Set(declaredNewFilePaths(goalDocument));
+    } catch (error) {
+      goalParseFailure ??= { checkName: 'goal-new-paths', message: oneLineConfidenceFailureDetail(error) };
+      return new Set<string>();
+    }
+  })();
   const invalidTracedPaths: Array<{ path: string; reason: 'occupied-new' | 'not-file' | 'missing' | 'inaccessible' }> = inspectionRoot
     ? authoredTracedPaths.flatMap<{ path: string; reason: 'occupied-new' | 'not-file' | 'missing' | 'inaccessible' }>((path) => {
       const occupation = tracedPathOccupation(path, inspectionRoot);
@@ -1315,7 +1332,8 @@ export function decideAskPreflight(
     ...(recentChangesUnknownReason ? { recentChangesUnknownReason } : {}),
   });
   const missingTracedPathBlockers: LaunchPreflightBlocker[] = [
-    ...(hasAuthoredGoal && authoredTracedPaths.length === 0 ? [{
+    // ⛔ 해석 실패를 「traced path 0」으로 한 번 더 뭉개지 않는다 — 그건 다른 갈래다.
+    ...(hasAuthoredGoal && authoredTracedPaths.length === 0 && goalParseFailure === undefined ? [{
       kind: 'missing-traced-path' as const,
       name: '최종 골의 TRACED PATHS 경로 0',
       detail: '정리 후 보존된 traced 경로가 없다 — 실제 파일 또는 유효한 신설: 파일 경로를 골에 선언해야 발사할 수 있다',
@@ -1347,16 +1365,29 @@ export function decideAskPreflight(
     checkName: 'goal-read',
     targetPath: resolvedGoalFile,
   }] : [];
+  const goalParseBlockers: LaunchPreflightBlocker[] = goalParseFailure ? [{
+    kind: 'goal-unreadable',
+    name: `골 문서 해석 실패: ${opts.goalFile}`,
+    detail: `${goalParseFailure.checkName} 검사가 골 문서를 해석하지 못했다(${goalParseFailure.message}) — 골 판독 실패(goal-unreadable)도 traced path 오류(missing-traced-path)도 아닌 별개 갈래다 · 어느 검사가 막았는지는 checkName 이 가른다 — 골의 TRACED PATHS · 신설: 문면을 바로잡아야 한다`,
+    reasonCode: 'goal-parse' as const,
+    checkName: goalParseFailure.checkName,
+    targetPath: resolvedGoalFile,
+  }] : [];
   const decisionResult = {
     ...result,
-    blockers: [...result.blockers, ...missingTracedPathBlockers, ...goalReadBlockers],
+    // ⛔ 해석 실패를 「대상 경로 0」 문면으로 덮지 않는다 — 사유 코드가 이미 그 자리를 말한다.
+    blockers: [
+      ...result.blockers.filter((blocker) => goalParseFailure === undefined || blocker.kind !== 'no-target-paths'),
+      ...missingTracedPathBlockers, ...goalParseBlockers, ...goalReadBlockers,
+    ],
     warnings: [...result.warnings, ...askMarkerWarnings],
     runningRunsConfidenceAppendix: runningRunsConfidence.appendix,
   };
   emittedAskMarkerObservations.add(decisionResult);
   return {
     result: decisionResult,
-    shouldLaunch: missingTracedPathBlockers.length === 0 && goalReadBlockers.length === 0 && (result.blockers.length === 0 || force),
+    shouldLaunch: missingTracedPathBlockers.length === 0 && goalParseBlockers.length === 0 && goalReadBlockers.length === 0
+      && (result.blockers.length === 0 || force),
     plannedBranchResolution,
   };
 }

package/src/self-dev/orchestrate-cli.ts

@@ -451,6 +451,7 @@ export async function runSelfOrchestrateCliCommand(
       await recordRoundPrs(results);
       results = await superviseRun({
         initial: results,
+        knowhowRepo: deps.repositoryRoot ?? process.cwd(),
         // The add-repair-task branch below runs each authored review-oscillation repair goal as that goal's new
         // feature (a fresh piece, same goal id) — the supervisor records the repair text, so a second oscillation stops.
         repairGoalExecution: true,

package/src/self-dev/orchestrate.ts

@@ -1520,6 +1520,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(disp?.ok !== undefined ? { ok: disp.ok } : {}),
           ...(disp?.prUrl ? { prUrl: disp.prUrl } : {}),
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
+          ...(disp?.goalPlanRevision ? { goalPlanRevision: disp.goalPlanRevision } : {}),
           ...(disp?.merged !== undefined ? { merged: disp.merged } : {}),
           ...(disp?.checkedHeadCommit ? { checkedHeadCommit: disp.checkedHeadCommit } : {}),
           ...(disp?.selfReview ? { selfReview: disp.selfReview } : {}),