elanous 0.2.32 → 0.2.35

package/src/task-agent/live-moves.ts

@@ -6,6 +6,10 @@
  *   TA-REVIEW-RESULT-CAPTURE — 자식 stdout(`--json`)은 결과 파일로 받고, 자식 완료 뒤 해당 카드만 회수·재판정한다.
  *   회수한 pass 는 그 틱의 판단부·land 관문 입력(`selfReview`)이 될 뿐 land 판정 로직은 그대로다.
  * - `propose-green`: 카드에 green «제안»(`greenProposal`)만 적는다 — 체크리스트는 손대지 않는다.
+ * - `propose-close`: TA-PROPOSE-CLOSE-MOVE — draft 정리(0.2.36 · 대표 10-21 · 열린 draft 301)의 닫기를 판단한다.
+ *   close-a(착지/대체)·close-b(같은 칸 새 draft)·close-c(48h+ 무커밋 ⊕ 주인 확인)의 근거 조건이
+ *   «모두 참»일 때만 그 draft 의 닫기 명령을 만든다. 보호 라벨·running·못 읽음은 근거가 참이어도 닫지 않는다(보류).
+ *   `propose` 모드는 닫기 명령 원문만 만들고, `live` 모드만 실제로 닫는다(실패는 ok:false 로 드러난다).
  * - `propose-land`: 카드·현재 머리의 self review 통과(pass «또는» warn ⊕ must-fix 0 · TA-LAND-WARN-MUSTFIX0)·non-draft 를 확인한다. 큐 설정이 있으면 원격 changed gate 뒤 착지 줄에 등록하고, 없으면 기존 `pr land` 를 머리 고정으로 한 번 부른다.
  * - 사다리 R4: `narrow-relaunch` · `wait-retry` · `salvage-relaunch` · `alternative` 도 허용 목록 어휘다 — 실제 발사는 실행부
  *   `executeNextAction`(`actions.ts`)이 «목록 ⊕ 같은 수 2회 상한 ⊕ 회당 1건 ⊕ 부하 관문»을 모두 넘을 때만 한다.
@@ -22,7 +26,9 @@ import { debug } from '../debug/log.js';
 import { findGitDir } from '../git-fs/locate.js';
 import { getUserConfig, userConfigPath } from '../user-config.js';
 import type { DetachedSpawn } from '../cli/tasks-cli.js';
-import { LIVE_MOVE_HISTORY_EVENT, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
+import { LIVE_MOVE_HISTORY_EVENT, shellQuote, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
+import { reconcileHandMergedCard } from './postland-card.js';
+import { resolveParentHosts, type ParentHostConfig } from './parent-host.js';
 import { LIVE_RETRY_MOVES } from './judge.js';
 import { decisionCardGrounds, decisionRaiseArgs, type DecisionCardEvidence, type NextAction } from './actions.js';
 import { pendingReviewResults, reviewResultPath, TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_RESULT_ENV, TA_REVIEW_COMPLETION_STATE_ENV } from './review-result-capture.js';
@@ -30,7 +36,7 @@ import { buildPriorFixContext, PRIOR_FIX_SCOPE_LINE, priorFixBlock, priorFixObse
 import { createLandWorktree, localBranch, localHead, observeLandWorktree, type LandWorktree, type LandWorktreeFailure, type LandWorktreeInput, type LandWorktreeRemoval } from './land-worktree.js';
 import { runQueuedLanding, type QueueLandingInput } from './land-queue.js';
 
-export const TASK_AGENT_LIVE_MOVES = ['review', 'propose-green', 'propose-land', 'decision-card', ...LIVE_RETRY_MOVES] as const;
+export const TASK_AGENT_LIVE_MOVES = ['review', 'propose-green', 'propose-land', 'propose-close', 'decision-card', ...LIVE_RETRY_MOVES] as const;
 export type TaskAgentLiveMove = typeof TASK_AGENT_LIVE_MOVES[number];
 export const TASK_AGENT_LIVE_MOVES_ENV = 'ELANOUS_TASK_AGENT_LIVE_MOVES';
 
@@ -83,6 +89,8 @@ export interface LiveMoveDeps {
   priorDiff?: PriorDiffReader;
   /** Fresh PR head and draft flag for landing; separate from the unchanged review lookup. */
   landPrHead?: (pr: number, cwd: string) => Promise<(PrHeadView & { isDraft: boolean }) | null>;
+  /** TA-CARD-MERGE-RECONCILE — MERGED PR 의 merge SHA·base·mergedAt 관측(시험 주입 · 기본 = `gh pr view`). */
+  handMergePr?: (pr: number, cwd: string) => Promise<HandMergePrView | null>;
   /** One existing pr land operation; inject in tests instead of invoking the CLI. */
   /** TA-REJUDGE-ON-HEAD — `opts.overlapEvidence` 가 있으면 `pr land --overlap-evidence <file>` 로 넘긴다(없으면 종전 인자). */
   land?: (pr: number, head: string, cwd: string, opts?: { overlapEvidence?: string }) => Promise<{ status: number; stdout: string; stderr?: string }>;
@@ -203,9 +211,24 @@ export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh)
   } catch { return null; }
 }
 
-/** 리뷰 요청 argv — 진입점 · 같은 우주(`--config-dir`) · `self review <PR> --json --intent`. */
+/** TA live reviews use the independent Claude ACP reviewer; self review owns same-head GLM fallback. */
 export function liveReviewArgs(entry: string, configDir: string, pr: number, intent: string): string[] {
-  return [resolve(entry), '--config-dir', configDir, 'self', 'review', String(pr), '--json', '--intent', intent];
+  return [resolve(entry), '--config-dir', configDir, 'self', 'review', String(pr), '--json', '--intent', intent, '--acp', '--acp-backend', 'claude'];
+}
+
+/** Use the configured node-b checkout for heavy TA workers; absence of parentHost preserves the legacy local path. */
+export function configuredMsb1Worker(): ParentHostConfig | null {
+  const setting = getUserConfig().taskAgent?.parentHost;
+  if (setting === undefined) return null;
+  const target = resolveParentHosts(setting, {} as NodeJS.ProcessEnv).find((entry) => entry.host === 'node-b');
+  if (!target) throw new Error('taskAgent.parentHost configured without a valid node-b worker');
+  return target;
+}
+
+export function remoteTaWorkerCommand(target: ParentHostConfig, args: readonly string[]): string {
+  const entry = target.elanous ? shellQuote(target.elanous) : '$HOME/.local/share/elanous/bin/elanous';
+  const configDir = target.configDir ? shellQuote(target.configDir) : '$HOME/.elanous';
+  return `cd ${shellQuote(target.cwd)} && ${entry} --config-dir ${configDir} ${args.map(shellQuote).join(' ')}`;
 }
 
 /**
@@ -214,19 +237,23 @@ export function liveReviewArgs(entry: string, configDir: string, pr: number, int
  * 파이프가 아니라 파일 — 부모가 먼저 끝나도 자식이 EPIPE 로 죽지 않는다). 없으면 종전과 같다(stdio ignore).
  * `opts` 는 시험 몫(spawn·진입점·우주) — 기본은 실물.
  */
-export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string; cardId?: string; statePath?: string } = {}): Promise<void> {
+export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string; cardId?: string; statePath?: string; remote?: ParentHostConfig | null } = {}): Promise<void> {
   const { spawnDetachedConfirmed, ELANOUS_CLI_ENTRY } = await import('../cli/tasks-cli.js');
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const configDir = opts.configDir ?? getElanousConfigDirOverride() ?? effectiveInstanceRoot();
   const base = opts.spawn ?? (spawn as unknown as DetachedSpawn);
+  const remote = opts.remote === undefined ? (opts.spawn ? null : configuredMsb1Worker()) : opts.remote;
   const args = liveReviewArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, pr, intent);
   const completionEnv = opts.resultPath && opts.cardId && opts.statePath ? {
     [TA_REVIEW_COMPLETION_CARD_ENV]: opts.cardId,
     [TA_REVIEW_COMPLETION_STATE_ENV]: opts.statePath,
     [TA_REVIEW_COMPLETION_RESULT_ENV]: opts.resultPath,
   } : undefined;
-  if (!opts.resultPath) { await spawnDetachedConfirmed(base, process.execPath, args, undefined, cwd); return; }
+  const workerCommand = remote ? remoteTaWorkerCommand(remote, ['self', 'review', String(pr), '--json', '--intent', intent, '--acp', '--acp-backend', 'claude']) : null;
+  const command = remote ? 'ssh' : process.execPath;
+  const workerArgs = remote ? ['-T', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5', remote.host, workerCommand!] : args;
+  if (!opts.resultPath) { await spawnDetachedConfirmed(base, command, workerArgs, undefined, cwd); return; }
   let fd: number;
   try {
     mkdirSync(dirname(opts.resultPath), { recursive: true });
@@ -234,13 +261,13 @@ export async function defaultRequestReview(pr: number, intent: string, cwd?: str
   } catch (error) {
     // 결과 파일을 못 열어도 리뷰는 막지 않는다(종전처럼 stdio ignore) — 회수는 상한 뒤 «no result» 줄로 드러난다.
     try { debug.log('task-agent', 'review-result-file-open-failed', { pr, resultPath: opts.resultPath, reason: (error instanceof Error ? error.message : String(error)).slice(-300) }, { level: 'warn' }); } catch { /* fail-soft */ }
-    await spawnDetachedConfirmed(base, process.execPath, args, undefined, cwd);
+    await spawnDetachedConfirmed(base, command, workerArgs, undefined, cwd);
     return;
   }
   const toFile: DetachedSpawn = (command, spawnArgs, options) =>
     (base as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, spawnArgs, { ...options, stdio: ['ignore', fd, 'ignore'] });
   try {
-    await spawnDetachedConfirmed(toFile, process.execPath, args, undefined, cwd, completionEnv);
+    await spawnDetachedConfirmed(toFile, command, workerArgs, undefined, cwd, remote ? undefined : completionEnv);
   } finally {
     try { closeSync(fd); } catch { /* the child keeps its own copy */ }
   }
@@ -296,6 +323,35 @@ export async function defaultLandPrHead(pr: number, cwd: string): Promise<(PrHea
   } catch { return null; }
 }
 
+/** TA-CARD-MERGE-RECONCILE — 손수 병합된 PR 의 정산 관측값(merge SHA 가 main 조상 검증의 재료). */
+export interface HandMergePrView {
+  state: string;
+  url?: string;
+  baseRefName?: string;
+  mergedAt?: string;
+  mergeCommit?: string;
+}
+
+export async function defaultHandMergePr(pr: number, cwd: string): Promise<HandMergePrView | null> {
+  const view = (env: NodeJS.ProcessEnv) => runGh(['pr', 'view', String(pr), '--json', 'state,url,baseRefName,mergedAt,mergeCommit'], { env, cwd });
+  let out = view(process.env);
+  if (out.status !== 0) {
+    const noProxy = { ...process.env };
+    for (const key of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy']) delete noProxy[key];
+    out = view(noProxy);
+  }
+  if (out.status !== 0) return null;
+  try {
+    const value = JSON.parse(out.stdout) as { state?: unknown; url?: unknown; baseRefName?: unknown; mergedAt?: unknown; mergeCommit?: { oid?: unknown } | null };
+    if (typeof value.state !== 'string') return null;
+    return { state: value.state,
+      ...(typeof value.url === 'string' && value.url ? { url: value.url } : {}),
+      ...(typeof value.baseRefName === 'string' && value.baseRefName ? { baseRefName: value.baseRefName } : {}),
+      ...(typeof value.mergedAt === 'string' && value.mergedAt ? { mergedAt: value.mergedAt } : {}),
+      ...(typeof value.mergeCommit?.oid === 'string' && /^[a-f0-9]{40}$/i.test(value.mergeCommit.oid) ? { mergeCommit: value.mergeCommit.oid } : {}) };
+  } catch { return null; }
+}
+
 /**
  * REVIEW-CONVERGE-PRIOR-FIX — `prior` 는 같은 PR 의 두 번째 이후 리뷰에만 온다: «직전 반영분»에 직전 머리 범위·diff·must-fix 를,
  * 범위 경계에 «바뀌지 않은 줄의 새 must-fix 는 근거 줄» 한 줄을 붙인다. 없으면(첫 리뷰) 종전 문면 바이트 그대로.
@@ -402,7 +458,7 @@ export async function executeLiveReview(
  *   (`executeLiveLand` ctx `gateAt` = 그 재게이트 요청 시각)에만 이 시도는 «소비됨»으로 빠진다. judgement·infra 와 섞이지 않는다.
  */
 export const LAND_ATTEMPTS_PER_HEAD_ON_INFRA = 2;
-export type LandFailureClass = 'infra' | 'judgement' | 'base-stale';
+export type LandFailureClass = 'infra' | 'judgement' | 'base-stale' | 'recovery';
 
 /** `pr land` 출력 줄 → 인프라 사유. ⛔ 줄 «전체»가 맞아야 한다 — 비슷한 문면을 넓게 받지 않는다. */
 export const LAND_INFRA_OUTPUT_REASONS: ReadonlyArray<{ reason: string; line: RegExp }> = [
@@ -422,6 +478,8 @@ const LAND_INFRA_CONSEQUENCE_LINES: ReadonlyArray<{ of: string; line: RegExp }>
 ];
 /** REJUDGE base-stale — 겹침 증거의 게이트 base 가 낡았고 그 사이 착지가 PR 파일을 건드렸다(`pr land` · #26060 문면). */
 const LAND_BASE_STALE_LINE = /^✗ overlap-evidence: (base-stale-overlap: .*)$/;
+const LAND_RECOVER_REVIEW = /^✗ (?:ancestor-auto|overlap-evidence): (?:review-missing|review-not-reviewed|review-error|review-no-result|review-unreadable|review-pr-mismatch|review-head-mismatch|review-path-not-for-this-pr-head|review-verdict-null|review-must-fix-unknown)(?:\b|$)/;
+const LAND_RECOVER_BUSY = /^✗ heavy-remote: (?:원격|병합 직전 원격|node-b) 게이트 gate-host-busy(?:\b|\s|$)/;
 /** base-stale 에 «딸려 나오는» 줄 — 증거가 거절되면 `pr land` 가 이어서 낸다(그 줄만 있으면 판정 거절로 세지 않는다). */
 const LAND_BASE_STALE_CONSEQUENCE_LINES: readonly RegExp[] = [/^✗ expected-head: overlap merge approval unavailable for the reviewed head$/];
 /** 실패가 아닌 ✗ 줄 — `pr land` 가 «계속합니다»로 넘어간다(판정에 쓰지 않는다). */
@@ -464,6 +522,10 @@ export function classifyLandFailure(outcome: { status: number; stdout?: string;
     if (hit) infra.add(hit.reason); else unlisted.push(line);
   }
   const judged = unlisted.filter((line) => !LAND_INFRA_CONSEQUENCE_LINES.some((entry) => infra.has(entry.of) && entry.line.test(line)));
+  if (judged.length === 1 && !infra.size) {
+    if (LAND_RECOVER_REVIEW.test(judged[0]!)) return { class: 'recovery', reason: 'review-missing' };
+    if (LAND_RECOVER_BUSY.test(judged[0]!)) return { class: 'recovery', reason: 'gate-host-busy' };
+  }
   // REJUDGE base-stale — 거절 줄이 base-stale-overlap(⊕ 딸린 줄) «뿐»이고 인프라 사유가 없을 때만. 하나라도 다른 ✗ 줄이 섞이면 judgement(fail-closed).
   const stale = judged.map((line) => LAND_BASE_STALE_LINE.exec(line)?.[1]).find((reason): reason is string => !!reason);
   if (stale && !infra.size && judged.every((line) => LAND_BASE_STALE_LINE.test(line) || LAND_BASE_STALE_CONSEQUENCE_LINES.some((re) => re.test(line)))) {
@@ -520,7 +582,20 @@ function observeLandWorktreeCreateCapped(deps: LiveMoveDeps, data: { card: strin
 /** 같은 머리에 한 번 더 시도해도 되나 — 앞 시도가 «전부» 끝났고(ok:false) «전부» infra 이고 상한 밑일 때만. */
 function landRetryAllowed(prior: readonly LandAttempt[]): boolean {
   return prior.length > 0 && prior.length < LAND_ATTEMPTS_PER_HEAD_ON_INFRA
-    && prior.every((entry) => entry.ok === false && (entry.class === 'infra' || legacyMissingTscRuntime(entry)));
+    && prior.every((entry) => entry.ok === false && (entry.class === 'infra' || entry.class === 'recovery' || legacyMissingTscRuntime(entry)));
+}
+
+function recoveryAdmissionReady(card: TaskCard, prior: readonly LandAttempt[], pr: number, head: string, nowMs = Date.now()): boolean {
+  const last = prior.at(-1);
+  if (last?.class !== 'recovery') return true;
+  if (last.reason === 'gate-host-busy') return nowMs >= Date.parse(last.at) + 30_000
+    && (card.history ?? []).some((event) => event.event === 'rejudge-on-head' && event.kind === 'land'
+      && event.effect === 'recover-wait-retry' && event.pr === pr && event.head?.toLowerCase() === head.toLowerCase()
+      && Date.parse(event.at) >= Date.parse(last.at));
+  if (last.reason === 'review-missing') return (card.reviewRequests ?? []).some((request) => request.pr === pr
+    && request.head.toLowerCase() === head.toLowerCase() && Date.parse(request.at) >= Date.parse(last.at) && !request.error)
+    && !pendingReviewResults(card).some((request) => request.pr === pr && request.head.toLowerCase() === head.toLowerCase());
+  return false;
 }
 
 /** A previous release classified a missing node interpreter as judgement; only that exact recorded shape may be reopened. */
@@ -541,8 +616,9 @@ export function openLandAttempts<T extends Pick<LandAttempt, 'at' | 'class'>>(pr
 }
 
 /** 카드의 이 PR·머리에 인프라 재시도가 남았나(재판정 틱이 «머리 그대로»여도 land 단계까지 가게). */
-export function landRetryPending(card: Pick<TaskCard, 'landAttempts'>, pr: number, head: string): boolean {
-  return landRetryAllowed((card.landAttempts ?? []).filter(sameHeadOf(pr, head)));
+export function landRetryPending(card: TaskCard, pr: number, head: string): boolean {
+  const attempts = (card.landAttempts ?? []).filter(sameHeadOf(pr, head));
+  return landRetryAllowed(attempts) && recoveryAdmissionReady(card, attempts, pr, head);
 }
 
 export const LAND_RETRY_ON_INFRA_EVENT = 'land-retry-on-infra';
@@ -575,7 +651,21 @@ export async function executeLiveLand(
   let view: (PrHeadView & { isDraft: boolean }) | null;
   try { view = await (deps.landPrHead ?? defaultLandPrHead)(pr, cwd); } catch { view = null; }
   if (!view || !/^[0-9a-f]{40}$/i.test(view.head)) return reject(card.id, `PR #${pr} head unknown`, reviewRepo);
-  if (view.state !== 'OPEN') return reject(card.id, `PR #${pr} is ${view.state}`, reviewRepo);
+  if (view.state !== 'OPEN') {
+    // TA-CARD-MERGE-RECONCILE — 실패 카드에 묶인 PR을 사람이 손수 병합한 경우만 이 자리에서 정산한다; 정산이 아니면 종전 거절 그대로.
+    if (view.state === 'MERGED') {
+      let hand: HandMergePrView | null = null;
+      try { hand = await (deps.handMergePr ?? defaultHandMergePr)(pr, cwd); } catch { hand = null; }
+      if (hand?.mergeCommit) {
+        const settled = reconcileHandMergedCard({ number: pr, url: hand.url ?? view.url ?? '', headRefOid: view.head, state: 'MERGED',
+          baseRefName: hand.baseRefName ?? 'main', mergedAt: hand.mergedAt ?? '', mergeCommit: hand.mergeCommit },
+          cwd, deps.statePath ? { statePath: deps.statePath } : {});
+        if (settled.outcome === 'reconciled')
+          return withRepo(observe(deps, { kind, card: card.id, ok: true, executed: true, detail: `PR #${pr} 손 병합 정산 — card ${settled.status} (merge ${settled.mergeSha.slice(0, 12)})` }));
+      }
+    }
+    return reject(card.id, `PR #${pr} is ${view.state}`, reviewRepo);
+  }
   if (view.isDraft !== false) return reject(card.id, `PR #${pr} is draft or draft status unknown`, reviewRepo);
   if (ctx.produced?.prUrl && (!view.url || view.url.trim().replace(/\/+$/, '').toLowerCase() !== ctx.produced.prUrl.trim().replace(/\/+$/, '').toLowerCase())) {
     return reject(card.id, `PR #${pr} URL mismatches run evidence`, reviewRepo);
@@ -622,7 +712,7 @@ export async function executeLiveLand(
         }
       }
       prior = openLandAttempts((current.landAttempts ?? []).filter(sameHeadOf(pr, view!.head)), ctx.gateAt);
-      if (prior.length && !landRetryAllowed(prior)) return undefined;
+      if (prior.length && (!landRetryAllowed(prior) || !recoveryAdmissionReady(current, prior, pr, view!.head, (deps.now ?? (() => new Date()))().getTime()))) return undefined;
       claimed = true;
       return { ...current, landAttempts: [...(current.landAttempts ?? []), { pr, head: view!.head, at }] };
     });
@@ -721,7 +811,7 @@ export async function executeLiveLand(
     detail = (error instanceof Error ? error.message : String(error)).slice(-300);
     failure = classifyLandFailure({ thrown: detail });
   }
-  const retryAllowed = failure?.class === 'infra' && attempt < LAND_ATTEMPTS_PER_HEAD_ON_INFRA;
+  const retryAllowed = (failure?.class === 'infra' || failure?.class === 'recovery') && attempt < LAND_ATTEMPTS_PER_HEAD_ON_INFRA;
   // 인프라 실패로 재시도가 남으면 주기 표시도 푼다 — 같은 주기 id(재판정 틱의 `rejudge:<card>:<head>`)가 그 한 번을 막지 않게.
   if (retryAllowed && cycle) landedCycles.delete(cycle);
   if (worktree && queueConfig && ok) {
@@ -790,6 +880,158 @@ export function executeLiveGreenProposal(card: TaskCard | undefined, evidence: R
   return observe(deps, { kind, executed: true, card: card.id, ok: true, detail: `green proposed (${Object.values(refs).join(', ')}) · checklist untouched` });
 }
 
+/**
+ * TA-PROPOSE-CLOSE-MOVE — draft 정리(0.2.36 · 대표 10-21)의 닫기 근거와 보류 조건.
+ * - close-a: draft 내용이 다른 곳에 착지되거나 대체됐다.
+ * - close-b: 같은 칸에 새 draft 가 열렸다(이 draft 는 대체됐다).
+ * - close-c: 48h+ 커밋 없음 ⊕ 칸 주인 확인 — 두 조건이 «모두» 참이어야 한다.
+ * - 보류: 보호 라벨·running·못 읽음(gh pr view 실패)·draft 아님·근거 없음 — 근거가 참이어도 닫지 않는다.
+ */
+export const CLOSE_IDLE_HOURS = 48;
+export const CLOSE_PROTECTED_LABELS = ['protected', 'do-not-close', 'keep-open'] as const;
+
+/** 가짜·실제 gh 우주가 돌려주는 draft 한 건의 닫기 판단 재료. */
+export interface DraftCloseView {
+  pr: number;
+  /** gh 로 draft 를 읽었는가 — 못 읽으면 닫지 않는다(fail-closed). */
+  readable: boolean;
+  isDraft: boolean;
+  labels?: readonly string[];
+  /** 진행 중 런에 붙은 draft — 닫지 않는다. */
+  running?: boolean;
+  /** close-a — 착지/대체. */
+  landedElsewhere?: boolean;
+  /** close-b — 같은 칸에 새 draft. */
+  newerDraftInSameCell?: boolean;
+  /** close-c — 마지막 커밋 이후 경과 시간(시). */
+  idleHours?: number;
+  /** close-c — 칸 주인 확인. */
+  ownerConfirmed?: boolean;
+}
+
+export interface DraftCloseGrounds { closeA: boolean; closeB: boolean; closeC: boolean; idle48h: boolean; ownerConfirmed: boolean }
+
+export type DraftCloseHeldBy = 'unreadable' | 'not-a-draft' | 'protected-label' | 'running' | 'no-grounds';
+
+export interface DraftCloseDecision {
+  pr: number;
+  /** 닫기 명령을 만들어도 되는가 — 근거가 참이고 보류 조건이 하나도 없을 때만. */
+  close: boolean;
+  /** 조건별 참/거짓 — 코멘트·관측의 재료. */
+  grounds: DraftCloseGrounds;
+  /** 근거 코멘트 — 조건별 참/거짓을 그대로 적는다. */
+  comment: string;
+  /** 닫기 명령 원문(보류면 null). */
+  command: string | null;
+  heldBy?: DraftCloseHeldBy;
+}
+
+/** 근거 코멘트 — 조건별 참/거짓을 전부 적는다(못 읽은 draft 도 같은 문면). */
+export function draftCloseGroundsComment(grounds: DraftCloseGrounds): string {
+  return `close-a(착지/대체)=${grounds.closeA} · close-b(같은 칸 새 draft)=${grounds.closeB}`
+    + ` · close-c(48h+ 무커밋=${grounds.idle48h}, 주인 확인=${grounds.ownerConfirmed})`;
+}
+
+/** draft 한 건의 닫기 판단 — 근거 조건이 모두 참이어야 그 근거가 성립하고, 보류 조건이 하나라도 있으면 닫지 않는다. */
+export function evaluateDraftClose(draft: DraftCloseView): DraftCloseDecision {
+  const grounds: DraftCloseGrounds = {
+    closeA: draft.landedElsewhere === true,
+    closeB: draft.newerDraftInSameCell === true,
+    closeC: false,
+    idle48h: typeof draft.idleHours === 'number' && Number.isFinite(draft.idleHours) && draft.idleHours >= CLOSE_IDLE_HOURS,
+    ownerConfirmed: draft.ownerConfirmed === true,
+  };
+  grounds.closeC = grounds.idle48h && grounds.ownerConfirmed;
+  const protectedLabel = (draft.labels ?? []).some((label) => (CLOSE_PROTECTED_LABELS as readonly string[]).includes(label));
+  const heldBy: DraftCloseHeldBy | undefined = !draft.readable ? 'unreadable'
+    : protectedLabel ? 'protected-label'
+    : draft.running === true ? 'running'
+    : draft.isDraft !== true ? 'not-a-draft'
+    : !(grounds.closeA || grounds.closeB || grounds.closeC) ? 'no-grounds'
+    : undefined;
+  const close = heldBy === undefined;
+  const comment = close
+    ? `draft 정리 — ${draftCloseGroundsComment(grounds)}`
+    : `draft 정리 보류(${heldBy}) — ${draftCloseGroundsComment(grounds)}`;
+  const command = close ? `gh pr close ${draft.pr} --comment ${shellQuote(comment)}` : null;
+  return { pr: draft.pr, close, grounds, comment, command, ...(close ? {} : { heldBy }) };
+}
+
+/** `gh pr close <pr> --comment <comment>` 인자 — 그대로 gh 로 간다. */
+export function liveCloseArgs(pr: number, comment: string): string[] {
+  return ['pr', 'close', String(pr), '--comment', comment];
+}
+
+/** 실물 닫기 — 같은 우주의 `gh pr close` 한 번(시험은 `closeDraft` 를 주입한다). */
+export async function defaultCloseDraft(pr: number, comment: string): Promise<void> {
+  const out = runGh(liveCloseArgs(pr, comment), { env: process.env });
+  if (out.status !== 0) throw new Error(`gh pr close ${pr} 실패: ${out.stdout.slice(-200)}`);
+}
+
+export interface LiveCloseDeps extends LiveMoveDeps {
+  /** `propose`(기본)는 명령 원문만 만들고, `live` 만 실제로 닫는다. */
+  mode?: 'propose' | 'live';
+  closeDraft?: (pr: number, comment: string) => Promise<void> | void;
+}
+
+export interface LiveCloseResult extends LiveMoveResult { proposals: DraftCloseDecision[] }
+
+function observeClose(deps: LiveMoveDeps, result: LiveCloseResult): LiveCloseResult {
+  try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'live-move', { ...result, live: true }); } catch { /* fail-soft */ }
+  return result;
+}
+
+/**
+ * `propose-close` — 카드에 묶인 draft 들의 닫기를 판단한다.
+ * propose 모드는 닫기 명령 원문(근거 코멘트 포함)만 만들고, live 모드만 `gh pr close`(또는 주입한 `closeDraft`)를 부른다.
+ * 보류(보호 라벨·running·못 읽음)는 어느 모드에서도 닫지 않는다.
+ */
+export async function executeLiveCloseProposal(
+  card: TaskCard | undefined,
+  drafts: readonly DraftCloseView[],
+  deps: LiveCloseDeps = {},
+): Promise<LiveCloseResult> {
+  const kind = 'propose-close' as const;
+  const proposals = drafts.map(evaluateDraftClose);
+  if (!card) return observeClose(deps, { kind, executed: false, card: null, ok: false, detail: 'no task card — stays shadow', proposals });
+  const detail = proposals.map((proposal) => proposal.close ? `#${proposal.pr} close — ${proposal.command}` : `#${proposal.pr} hold — ${proposal.heldBy}`).join(' · ') || 'no drafts';
+  if (deps.mode !== 'live') return observeClose(deps, { kind, executed: false, card: card.id, ok: true, detail, proposals });
+  const path = deps.statePath ?? taskAgentStatePath();
+  const at = (deps.now ?? (() => new Date()))().toISOString();
+  const closable = proposals.filter((proposal) => proposal.close);
+  const failures: string[] = [];
+  for (const proposal of closable) {
+    try {
+      await (deps.closeDraft ?? defaultCloseDraft)(proposal.pr, proposal.comment);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      failures.push(`#${proposal.pr}: ${reason.slice(-200)}`);
+      try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'live-close-failed', { card: card.id, pr: proposal.pr, reason }); } catch { /* fail-soft */ }
+    }
+  }
+  const executed = closable.length > 0;
+  const ok = failures.length === 0;
+  try {
+    updateTaskCard(path, card.id, (current) => current ? {
+      ...current,
+      history: [...(current.history ?? []), ...closable.map((proposal) => ({
+        at,
+        event: LIVE_MOVE_HISTORY_EVENT,
+        kind,
+        executed,
+        executorResult: 'live' as const,
+        pr: proposal.pr,
+        ok: !failures.some((failure) => failure.startsWith(`#${proposal.pr}:`)),
+        detail: `close #${proposal.pr} — ${proposal.comment}`,
+        effect: `draft #${proposal.pr} close 명령 실행 · 근거 ${draftCloseGroundsComment(proposal.grounds)}`,
+      }))],
+    } : undefined);
+  } catch (error) {
+    return observeClose(deps, { kind, executed, card: card.id, ok: false, detail: `${detail} · card update failed: ${String(error).slice(-200)}`, proposals });
+  }
+  return observeClose(deps, { kind, executed, card: card.id, ok, detail: ok ? detail : `close 실패 — ${failures.join(' · ')}`, proposals });
+}
+
 export interface LiveDecisionCardContext {
   runId: string | null; stopReason: string; reason: string; pr?: number;
   risk?: NextAction['risk'];