elanous 0.2.37 → 0.2.38

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/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 } : {}),

package/src/self-dev/run-supervisor.ts

@@ -374,6 +374,21 @@ export function decideNextRun(input: {
   const deployFindings = input.deployFindings === undefined ? undefined
     : new Map([...input.deployFindings].filter(([taskId]) => !handedOffIds.has(taskId)));
   const t = triageRun(activeResults, deployFindings, observation === 'failed', undefined, mainSyncRelaunchSpent(history));
+  const revisionUnobserved = activeResults.filter((result) => result.harvestable === true && !!result.branch
+    && result.goalPlanRevision?.status !== 'read');
+  const revisionUnobservedIds = new Set(revisionUnobserved.map((result) => result.taskId));
+  for (const classification of t.classifications) {
+    if (classification.kind !== 'main-sync-blocked' || classification.action !== 'relaunch-on-main'
+      || !revisionUnobservedIds.has(classification.taskId)) continue;
+    // Keep history's «already spent» predicate separate from this independent safety block.
+    classification.action = 'needs-human';
+    t.relaunchOnMain = t.relaunchOnMain.filter((taskId) => taskId !== classification.taskId);
+    if (!t.needsHuman.includes(classification.taskId)) t.needsHuman.push(classification.taskId);
+  }
+  t.actionable = countActionable(t) > 0;
+  const revisionHoldNote = revisionUnobserved.length > 0
+    ? ` · 골 개정 관측 미확인 — 같은 골 재발사 보류(${revisionUnobserved.map((result) => result.taskId).join(', ')})`
+    : '';
   const relaunchGoals: Record<string, string> = Object.fromEntries(activeResults.flatMap((result) =>
     t.relaunchOnMain.includes(result.taskId) && result.branch
       ? [[result.taskId, mainSyncRelaunchGoal(result.feature, result.branch)]] : []));
@@ -438,7 +453,7 @@ export function decideNextRun(input: {
       ...base,
       action: 'stop',
       stopReason: 'harvestable-awaiting-human',
-      why: withGoalPlanRevisionObservation(`구현 완료 · 수확 대기 — ${harvestable.map((result) => result.branch).join(' · ')}`),
+      why: `${withGoalPlanRevisionObservation(`구현 완료 · 수확 대기 — ${harvestable.map((result) => result.branch).join(' · ')}`)}${revisionHoldNote}`,
     };
   }
 
@@ -604,7 +619,7 @@ export function decideNextRun(input: {
         ...base,
         action: 'stop',
         stopReason: 'no-progress',
-        why: withNoProgressGoalPlanRevisionObservation(`${stallRounds}라운드 연속 제자리 — base=${completionBase ?? 'main'} 기준 완료 ${baseCompleted} · 착지 ${landed} · 남은 조각도 안 줄었다(${actionable}). 골·불변식을 의심할 자리`),
+        why: `${withNoProgressGoalPlanRevisionObservation(`${stallRounds}라운드 연속 제자리 — base=${completionBase ?? 'main'} 기준 완료 ${baseCompleted} · 착지 ${landed} · 남은 조각도 안 줄었다(${actionable}). 골·불변식을 의심할 자리`)}${revisionHoldNote}`,
       };
     }
   }
@@ -733,10 +748,10 @@ export function decideNextRun(input: {
         ...(action === 'add-repair-task' && held.length ? { heldTaskIds: held } : {}) },
       pendingDecision: 'attempt-care-escalation',
       why: fresh.length === 0
-        ? `리뷰 진동 반복 — ${signatureOf(oscillating)} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}`
+        ? `리뷰 진동 반복 — ${signatureOf(oscillating)} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}${revisionHoldNote}`
         : cannotRepair
-          ? `리뷰 진동 — ${signatureOf(oscillating)} · ${input.repairGoalExecution === false ? '이 감독 경로가 수리 골 실행을 선언하지 않았다(미선언 또는 불가)' : '수리 원문/PR 관측 불가'} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}`
-          : `리뷰 진동 — ${signatureOf(fresh)} · review-oscillation 수리 조각을 한 번 붙인다${input.repairGoalExecution === true ? '' : '(실행 배선 미선언 — 결정 칸만)'}${repairedHeld.length ? ` · 이미 수리한 조각 ${repairedHeld.join(', ')} 은 사람 결정 대기` : ''}${classHeld.length ? ` · 분류로 보류한 조각 ${classHeld.join(', ')}` : ''}${heldReasonSuffix}`,
+          ? `리뷰 진동 — ${signatureOf(oscillating)} · ${input.repairGoalExecution === false ? '이 감독 경로가 수리 골 실행을 선언하지 않았다(미선언 또는 불가)' : '수리 원문/PR 관측 불가'} · 사람 결정 필요(같은 전략 재발사 금지)${heldReasonSuffix}${revisionHoldNote}`
+          : `리뷰 진동 — ${signatureOf(fresh)} · review-oscillation 수리 조각을 한 번 붙인다${input.repairGoalExecution === true ? '' : '(실행 배선 미선언 — 결정 칸만)'}${repairedHeld.length ? ` · 이미 수리한 조각 ${repairedHeld.join(', ')} 은 사람 결정 대기` : ''}${classHeld.length ? ` · 분류로 보류한 조각 ${classHeld.join(', ')}` : ''}${heldReasonSuffix}${revisionHoldNote}`,
     };
   }
 
@@ -746,14 +761,14 @@ export function decideNextRun(input: {
     return {
       ...base,
       action: 'add-repair-task',
-      why: `수리 조각을 붙인다 — 수리 ${t.repairable.length} · 그대로 재실행 ${t.rerunnable.length} · 재작업 ${t.reworkable.length} · 분해 ${t.decomposable.length} · 라운드 ${round + 1}/${maxRounds}`,
+      why: `수리 조각을 붙인다 — 수리 ${t.repairable.length} · 그대로 재실행 ${t.rerunnable.length} · 재작업 ${t.reworkable.length} · 분해 ${t.decomposable.length} · 라운드 ${round + 1}/${maxRounds}${revisionHoldNote}`,
     };
   }
 
   return {
     ...base,
     action: 'relaunch',
-    why: `다시 건다 — 그대로 재실행 ${t.rerunnable.length} · 재작업 ${t.reworkable.length} · 분해 ${t.decomposable.length} · 수리 ${t.repairable.length}${t.relaunchOnMain.length > 0 ? ` · main 위 재발사 ${t.relaunchOnMain.length}` : ''} · 라운드 ${round + 1}/${maxRounds}`,
+    why: `다시 건다 — 그대로 재실행 ${t.rerunnable.length} · 재작업 ${t.reworkable.length} · 분해 ${t.decomposable.length} · 수리 ${t.repairable.length}${t.relaunchOnMain.length > 0 ? ` · main 위 재발사 ${t.relaunchOnMain.length}` : ''} · 라운드 ${round + 1}/${maxRounds}${revisionHoldNote}`,
   };
 }