elanous 0.2.27 → 0.2.29

package/src/task-agent/cover.ts

@@ -8,7 +8,7 @@ export interface CoverRow {
   byTaskAgent: number | null;
   /** Total work by all seats; null when no independent denominator is available. */
   total: number | null;
-  /** TASK-AGENT events observed for this verb, including non-done outcomes; null if unreadable. */
+  /** TASK-AGENT action events observed for this verb; null if unreadable. */
   observedActions: number | null;
   ratio: number | null;
   state: 'measured' | 'no-denominator' | 'unreadable';
@@ -23,6 +23,8 @@ export interface CoverRow {
 /** null means the source could not be read; [] means it was read and had no matching events. */
 export interface TaskAgentCoverInput {
   taskAgentActions: readonly { kind: NextActionKind; result: string; reason?: string; taskId?: string }[] | null;
+  /** Actual land executor outcomes; omitted or null means the source was not read. */
+  liveLandMoves?: readonly { card: string; executed: boolean; ok: boolean }[] | null;
   allLands: readonly { step: string; ok: boolean }[] | null;
   /** Card-ledger denominator for review·retry·green. undefined = not requested; null = ledger unreadable; [] = no cards. */
   taskCards?: readonly { id: string }[] | null;
@@ -32,10 +34,26 @@ export interface TaskAgentCoverInput {
   /** null means the pending-landing age source could not be read; [] means no pending landings. */
   pendingLandingAgeSeconds?: readonly number[] | null;
   /** A source reached the query safety limit; its aggregate is not known to be complete. */
-  truncated?: { taskAgentActions: boolean; allLands: boolean; goalAsks?: boolean; goalRuns?: boolean };
+  truncated?: { taskAgentActions: boolean; allLands: boolean; liveLandMoves?: boolean; goalAsks?: boolean; goalRuns?: boolean; implementCardRuns?: boolean; implementRunMerges?: boolean };
   /** Completed authoring provenance and terminal goal records. undefined = not wired; null = unreadable. */
   goalAsks?: readonly { authorRunId: string; goalId: string }[] | null;
   goalRuns?: readonly { goalId: string; outcome: string; stage?: string }[] | null;
+  /** 구현 출처 — TA 카드의 런 결합. undefined = 이 동사의 출처 배선이 없다(no-source); null = 카드 원장을 못 읽었다; [] = 읽고 카드 없음. */
+  implementCardRuns?: readonly ImplementCardRunBinding[] | null;
+  /** 구현 출처 — 런 원장의 merged 사건. undefined = 배선 없음; null = 런 원장을 못 읽음. */
+  implementRunMerges?: ReadonlyMap<string, ImplementRunMergeEvent> | null;
+}
+
+/** 구현 동사의 카드 결합 — runId·runChildId 는 그 카드가 발사한 런이다. */
+export interface ImplementCardRunBinding {
+  cardId: string;
+  runId?: string | null;
+  runChildId?: string | null;
+}
+
+/** 구현 동사의 원장 merged 사건 — merged=true 만 완료 구현으로 센다. */
+export interface ImplementRunMergeEvent {
+  merged: boolean;
 }
 
 export type LandingFailureReason = 'load' | 'oom' | 'time-limit' | 'conflict' | 'review' | 'other';
@@ -52,6 +70,24 @@ export interface LandingThroughput {
 
 const FAILURE_REASONS: readonly LandingFailureReason[] = ['load', 'oom', 'time-limit', 'conflict', 'review', 'other'];
 
+function successfulLandCount(input: TaskAgentCoverInput): number | null {
+  if (input.taskAgentActions === null || input.truncated?.taskAgentActions
+    || input.liveLandMoves == null || input.truncated?.liveLandMoves) return null;
+  const cards = new Set<string>();
+  for (const action of input.taskAgentActions) {
+    if (action.kind !== 'land' || action.result !== 'done') continue;
+    // Without a card identity an action may duplicate a live-move; its count is unknown.
+    if (!action.taskId) return null;
+    cards.add(action.taskId);
+  }
+  for (const move of input.liveLandMoves) {
+    if (!move.executed || !move.ok) continue;
+    if (!move.card) return null;
+    cards.add(move.card);
+  }
+  return cards.size;
+}
+
 function landingFailureReason(action: { kind: NextActionKind; reason?: string }): LandingFailureReason {
   const reason = action.reason ?? '';
   if (/\boom\b|out[- ]of[- ]memory|oomkilled|메모리.{0,12}(초과|부족|킬)/i.test(reason)) return 'oom';
@@ -65,9 +101,7 @@ function landingFailureReason(action: { kind: NextActionKind; reason?: string })
 /** Daily funnel, failure-reason distribution, and oldest pending-landing age. */
 export function measureLandingThroughput(input: TaskAgentCoverInput): LandingThroughput {
   const actionsReadable = input.taskAgentActions !== null && input.truncated?.taskAgentActions !== true;
-  const taskAgentLandings = actionsReadable
-    ? input.taskAgentActions!.filter((action) => action.kind === 'land' && action.result === 'done').length
-    : null;
+  const taskAgentLandings = actionsReadable ? successfulLandCount(input) : null;
   const failureReasons = actionsReadable
     ? Object.fromEntries(FAILURE_REASONS.map((reason) => [reason, 0])) as Record<LandingFailureReason, number>
     : null;
@@ -112,7 +146,8 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
   const rows = verbs.map((verb): CoverRow => {
     const actions = input.taskAgentActions?.filter((action) => action.kind === verb);
     const actionsUnreadable = actions === undefined || input.truncated?.taskAgentActions === true;
-    const byTaskAgent = actionsUnreadable ? null : actions.filter((action) => action.result === 'done').length;
+    const byTaskAgent = verb === 'land' ? successfulLandCount(input)
+      : actionsUnreadable ? null : actions.filter((action) => action.result === 'done').length;
     const observedActions = actionsUnreadable ? null : actions.length;
     const liveActions = actionsUnreadable ? null : actions.filter((action) => action.result !== 'shadow').length;
     const shadowActions = actionsUnreadable ? null : actions.filter((action) => action.result === 'shadow').length;
@@ -137,7 +172,7 @@ export function measureTaskAgentCover(input: TaskAgentCoverInput): CoverRow[] {
     };
     const total = input.allLands === null || input.truncated?.allLands
       ? null : input.allLands.filter((land) => land.step === 'merge' && land.ok === true).length;
-    const state = actionsUnreadable || total === null ? 'unreadable'
+    const state = byTaskAgent === null || total === null ? 'unreadable'
       : total === 0 ? 'no-denominator' : 'measured';
     const ratio = state === 'measured' && byTaskAgent !== null && total !== null ? byTaskAgent / total : null;
     return { verb, byTaskAgent, total, observedActions, ratio, state, ...counts,
@@ -167,20 +202,20 @@ export type SevenVerbName = '리뷰' | '착지' | '수리' | '검증' | '저작'
 /** no-source 는 출처 배선이 없는 동사 · unreadable 은 해당 동사의 원천을 완전히 못 읽은 것이다. */
 export type SevenVerbState = 'live' | 'shadow-only' | 'none' | 'no-source' | 'unreadable';
 
-/** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 TASK-AGENT action kind, null 이면 출처가 아직 없다. */
+/** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 원천, null 이면 출처가 아직 없다. */
 export interface SevenVerbSource {
   verb: SevenVerbName;
-  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | null;
+  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | 'card-run+merged' | null;
 }
 
-/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현·정리는 아직 출처가 없다. */
+/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현은 카드 런 결합 ⊕ 원장 merged 조인; 정리는 아직 출처가 없다. */
 export const SEVEN_VERB_SOURCES: readonly SevenVerbSource[] = [
   { verb: '리뷰', source: 'review' },
   { verb: '착지', source: 'land' },
   { verb: '수리', source: 'retry' },
   { verb: '검증', source: 'green' },
   { verb: '저작', source: 'goal-ask+goal-run' },
-  { verb: '구현', source: null },
+  { verb: '구현', source: 'card-run+merged' },
   { verb: '정리', source: null },
 ];
 
@@ -200,12 +235,37 @@ export interface SevenVerbLive {
   measuredVerbs: number;
 }
 
-/** 행동 동사는 창 안의 done, 저작은 완료한 저작 원장과 착지 골의 조인. 각 출처의 null·절단은 해당 동사만 unreadable. */
+/** 행동 동사는 창 안의 done, 저작은 완료한 저작 원장과 착지 골의 조인, 구현은 카드 런 결합과 원장 merged 사건의 조인. 각 출처의 null·절단은 해당 동사만 unreadable. */
 export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive {
   const unreadable = input.taskAgentActions === null || input.truncated?.taskAgentActions === true;
   const verbs = SEVEN_VERB_SOURCES.map(({ verb, source }): SevenVerbLiveRow => {
+    if (source === 'card-run+merged') {
+      // ⛔ 배선이 없으면 출처가 «있는» 동사로 거짓 측정을 하지 않는다 — no-source 로 그대로 둔다.
+      if (input.implementCardRuns === undefined && input.implementRunMerges === undefined) {
+        return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
+      }
+      if (input.implementCardRuns == null || input.implementRunMerges == null
+        || input.truncated?.implementCardRuns === true || input.truncated?.implementRunMerges === true) {
+        return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+      }
+      const merges = input.implementRunMerges;
+      const cards = new Set<string>();
+      for (const binding of input.implementCardRuns) {
+        // 카드 신원 없이는 중복 없는 분자를 낼 수 없다 — 그 원장은 못 읽은 것으로 한다.
+        if (!binding.cardId) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+        const bound = [binding.runId, binding.runChildId];
+        if (bound.some((runId) => typeof runId === 'string' && runId && merges.get(runId)?.merged === true)) {
+          cards.add(binding.cardId);
+        }
+      }
+      const liveDone = cards.size;
+      return { verb, source, liveDone, shadow: 0, state: liveDone >= 1 ? 'live' : 'none' };
+    }
     if (source === null) return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
-    if (source !== 'goal-ask+goal-run' && unreadable) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+    if (source !== 'goal-ask+goal-run' && (unreadable || (source === 'land'
+      && (input.liveLandMoves == null || input.truncated?.liveLandMoves)))) {
+      return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+    }
     if (source === 'goal-ask+goal-run') {
       if (input.goalAsks == null || input.goalRuns == null || input.truncated?.goalAsks || input.truncated?.goalRuns) {
         return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
@@ -216,14 +276,15 @@ export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive
       return { verb, source, liveDone, shadow: 0, state: liveDone > 0 ? 'live' : 'none' };
     }
     const actions = input.taskAgentActions!.filter((action) => action.kind === source);
-    const liveDone = actions.filter((action) => action.result === 'done').length;
+    const liveDone = source === 'land' ? successfulLandCount(input) : actions.filter((action) => action.result === 'done').length;
+    if (liveDone === null) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
     const shadow = actions.filter((action) => action.result === 'shadow').length;
     return { verb, source, liveDone, shadow, state: liveDone >= 1 ? 'live' : shadow >= 1 ? 'shadow-only' : 'none' };
   });
   return {
     verbs,
     liveVerbs: verbs.some((row) => row.state === 'unreadable' && row.source !== null) ? null : verbs.filter((row) => row.state === 'live').length,
-    measuredVerbs: SEVEN_VERB_SOURCES.filter((row) => row.source !== null).length,
+    measuredVerbs: verbs.filter((row) => row.source !== null).length,
   };
 }
 
@@ -232,9 +293,15 @@ export function formatSevenVerbLive(measurement: SevenVerbLive): string {
   const total = SEVEN_VERB_SOURCES.length;
   if (measurement.liveVerbs === null) {
     const actionUnreadable = measurement.verbs.some((row) => row.source === 'review' && row.state === 'unreadable');
+    const landUnreadable = measurement.verbs.some((row) => row.source === 'land' && row.state === 'unreadable');
     const authorUnreadable = measurement.verbs.some((row) => row.source === 'goal-ask+goal-run' && row.state === 'unreadable');
-    const reason = actionUnreadable && authorUnreadable ? '행동·저작·골 원장 null·절단'
-      : actionUnreadable ? '행동 원장 null·절단' : '저작·골 원장 null·절단';
+    const implementUnreadable = measurement.verbs.some((row) => row.source === 'card-run+merged' && row.state === 'unreadable');
+    const failures = [
+      actionUnreadable ? '행동' : landUnreadable ? '착지' : null,
+      authorUnreadable ? '저작·골' : null,
+      implementUnreadable ? '구현 카드·런' : null,
+    ].filter((part): part is string => part !== null);
+    const reason = `${failures.join('·') || '저작·골'} 원장 null·절단`;
     const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
     return `${total}동사 live -/${total} · 못 잼(${reason})${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
   }

package/src/task-agent/failure-notify.ts

@@ -0,0 +1,61 @@
+import { defaultMsgStorePath, openMsgStore } from '../msg/msg-store.js';
+import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
+import type { CardRunSnapshot, CardRunEvidence } from './card-evidence.js';
+import { remoteParentAlive, type SshRunner } from './parent-host.js';
+import type { TaskCard } from './task-hand.js';
+
+const STOP_LINE = /\[supervisor\] 정지\((needs-human|no-progress)\)\s*[—-]\s*(.*)/u;
+
+/** A remote parent's terminal stop is usable only after every referenced child ledger was read. */
+export function remoteFailureReason(card: TaskCard, snapshot: CardRunSnapshot, evidence: CardRunEvidence, ssh?: SshRunner): string | undefined {
+  if (!card.parentHost || !card.runId || !snapshot.host || snapshot.readErrors?.length || card.pr || evidence.pr) return undefined;
+  const launchRows = snapshot.host.filter((row) => row.event === 'pod-child-run');
+  const childRefs = launchRows.map((row) => row.data?.childRunId);
+  // An unreadable or malformed child reference is unknown evidence, never "no children".
+  if (childRefs.some((id) => typeof id !== 'string' || !/^run-[A-Za-z0-9_-]{4,64}$/.test(id) || id === card.runId)) return undefined;
+  const children = childRefs as string[];
+  if (children.some((id) => !snapshot.children[id])) return undefined;
+  // The parent can stop while a child still runs. That child may publish a PR or salvage
+  // branch later, so every launched child must have a terminal last status first.
+  if (children.some((id) => {
+    const lastStatus = [...(snapshot.children[id] ?? [])].reverse().find((row) => row.event === 'run-status');
+    return !lastStatus || !['completed', 'failed', 'cancelled'].includes(String(lastStatus.data?.runStatus));
+  })) return undefined;
+  const rows: RunLedgerEntry[] = [...snapshot.host, ...children.flatMap((id) => snapshot.children[id] ?? [])];
+  if (rows.some((row) => row.event === 'pr-opened' || row.event === 'salvaged'
+    || (typeof row.data.harvestBranch === 'string' && row.data.harvestBranch.trim())
+    || (typeof row.data.salvageBranch === 'string' && row.data.salvageBranch.trim()))) return undefined;
+  const parentRows = snapshot.host.filter((row) => row.runId === card.runId);
+  const stopIndex = parentRows.map((row) => row.event).lastIndexOf('stop');
+  const stop = parentRows[stopIndex];
+  if (!stop) return undefined;
+  // A running status before stop is superseded by the supervisor's terminal stop.
+  // A fresh execution event after stop makes that stop stale for the current parent.
+  if (parentRows.slice(stopIndex + 1).some((row) => row.event === 'start' || row.event === 'pod-child-run'
+    || (row.event === 'run-status' && !['completed', 'failed', 'cancelled'].includes(String(row.data?.runStatus))))) return undefined;
+  const tail = Array.isArray(stop?.data.tail) ? stop.data.tail : [];
+  const lines = tail.filter((line): line is string => typeof line === 'string');
+  // A parent or terminal child stop can carry a PR or salvage branch only in raw text.
+  // Any nonempty branch token is harvest evidence, regardless of its naming prefix.
+  const stopText = rows.filter((row) => row.event === 'stop')
+    .flatMap((row) => [row.data.cause, ...(Array.isArray(row.data.tail) ? row.data.tail : [])])
+    .filter((value): value is string => typeof value === 'string').join('\n');
+  if (/https:\/\/github\.com\/[^\s]+\/pull\/\d+|ELANOUS_POD_SALVAGE(?:\s*=\s*|\s+)\S+|수확할 브랜치:\s*\S+/.test(stopText)) return undefined;
+  const matched = [...lines].reverse().map((line) => STOP_LINE.exec(line.replace(/\x1b\[[0-9;]*m/g, ''))).find((match) => match !== null);
+  if (!matched || remoteParentAlive({ ...card.parentHost, runId: card.runId }, ssh) !== 'dead') return undefined;
+  const raw = matched[2]?.replace(/[\r\n]+/g, ' ').trim();
+  if (!raw) return undefined;
+  return `${matched[1]} — ${raw}`;
+}
+
+/** SQLite provenance makes repeated refreshes insert precisely one message for this card/run/seat. */
+export function notifyRemoteFailure(card: TaskCard, reason: string, messageStorePath = defaultMsgStorePath()): void {
+  if (!card.seat || !card.runId || !card.parentHost) return;
+  const log = card.parentHost.log ?? `${card.parentHost.configDir ?? '$HOME/.elanous'}/remote-parents/${card.runId}.log`;
+  const store = openMsgStore(messageStorePath);
+  try {
+    store.appendWithProvenance({ from: 'TC', to: card.seat, kind: 'incident',
+      body: `TA 카드 ${card.id} · 원격 부모 ${card.parentHost.host} 종결 · 사유: ${reason}\n원격 로그: ${log}` },
+    `ta-failure:${card.id}-${card.runId}:${card.seat}`);
+  } finally { store.close(); }
+}

package/src/task-agent/green-sweep.ts

@@ -0,0 +1,170 @@
+/**
+ * GREEN-FROM-LEDGER, first slice: decide from a bound card or an explicit
+ * checklist evidence line.  This module never writes a checklist or card.
+ */
+import type { ChecklistItem } from '../release-loop/checklist.js';
+import { debug } from '../debug/log.js';
+import { cardPrNumber, type TaskCard } from './task-hand.js';
+
+export type GreenSweepVerdict = 'green' | 'record-only' | 'skip';
+export interface GreenSweepCandidate {
+  cell: string;
+  pr: number;
+  source: 'card' | 'evidence';
+  card?: TaskCard;
+  ambiguousAcrossCards?: boolean;
+}
+export interface GreenSweepPr {
+  number: number;
+  state: string;
+  mergeSha?: string;
+  url?: string;
+}
+export interface GreenSweepDecision {
+  cell: string;
+  pr: number;
+  mergeSha: string | null;
+  source: GreenSweepCandidate['source'];
+  verdict: GreenSweepVerdict;
+  reason: string;
+  evidence: string;
+  existingEvidence: string;
+  /** Preview only; a later live operation may persist this complete value. */
+  plannedEvidence: string;
+}
+
+/** PR-body mentions are intentionally absent from this parser. */
+export function explicitEvidencePrs(evidence: string | undefined): number[] {
+  const numbers = new Set<number>();
+  for (const line of (evidence ?? '').split(/\r?\n/)) {
+    // A previous refusal is diagnostic text, never new landing evidence.
+    if (/^GREEN-FROM-LEDGER:/i.test(line) && !/· green ·/.test(line)) continue;
+    // A negated landing claim cannot establish this cell's PR ownership.
+    if (/미착지|미병합|예정|계획|아님|않음|안\s*함|보류|대기|실패|불가|아직|미완료|누락|못\s*함|(?:착지|병합)\s*전|\b(?:not\s+(?:yet\s+)?(?:merged|landed)|unmerged|pending|planned)\b/i.test(line)) continue;
+    // A PR number only counts when this cell's own evidence calls it landed.
+    for (const match of line.matchAll(/(?:착지|병합|merged|landed)\s*(?:PR\s*)?#(\d+)\b|(?:PR\s*)?#(\d+)\s*(?:착지|병합|merged|landed)(?=$|[^A-Za-z가-힣])/gi)) {
+      const number = Number(match[1] ?? match[2]);
+      if (Number.isSafeInteger(number) && number > 0) numbers.add(number);
+    }
+    for (const match of line.matchAll(/https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)\b\s*(?:착지|병합|merged|landed)|(?:착지|병합|merged|landed)\s*https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)\b/gi)) {
+      const number = Number(match[1] ?? match[2]);
+      if (Number.isSafeInteger(number) && number > 0) numbers.add(number);
+    }
+  }
+  return [...numbers];
+}
+
+export function greenSweepCandidates(item: ChecklistItem, version: string, cards: readonly TaskCard[]): GreenSweepCandidate[] {
+  if (item.status !== 'yellow' && item.status !== 'red') return [];
+  const candidates = new Map<number, GreenSweepCandidate>();
+  for (const number of explicitEvidencePrs(item.evidence)) candidates.set(number, { cell: item.id, pr: number, source: 'evidence' });
+  for (const card of cards) {
+    if (card.checklistId !== item.id || (card.checklistVersion && card.checklistVersion !== version)
+      || (card.completion ?? 'code-pr') !== 'code-pr') continue;
+    const pr = cardPrNumber(card);
+    if (!pr) continue;
+    // Multiple cards claiming one PR are ambiguous, even if one has a complete marker.
+    if (candidates.get(pr)?.source === 'card') candidates.set(pr, { cell: item.id, pr, source: 'card' });
+    else candidates.set(pr, { cell: item.id, pr, source: 'card', card });
+  }
+  return [...candidates.values()].map((candidate) => ({ ...candidate,
+    ambiguousAcrossCards: cards.filter((card) => cardPrNumber(card) === candidate.pr).length > 1,
+  })).sort((a, b) => a.pr - b.pr);
+}
+
+export function ambiguousGreenSweepPrs(items: readonly ChecklistItem[], version: string, cards: readonly TaskCard[]): Set<number> {
+  const claims = new Map<number, Set<string>>();
+  for (const item of items) {
+    const numbers = new Set(explicitEvidencePrs(item.evidence));
+    for (const card of cards) {
+      if (card.checklistId === item.id && (!card.checklistVersion || card.checklistVersion === version)
+        && (card.completion ?? 'code-pr') === 'code-pr') {
+        const pr = cardPrNumber(card);
+        if (pr) numbers.add(pr);
+      }
+    }
+    for (const pr of numbers) {
+      const cells = claims.get(pr) ?? new Set<string>();
+      cells.add(item.id);
+      claims.set(pr, cells);
+    }
+  }
+  return new Set([...claims].filter(([, cells]) => cells.size > 1).map(([pr]) => pr));
+}
+
+export function appendGreenSweepEvidence(existing: string | undefined, line: string): string {
+  const before = existing ?? '';
+  if (before.split(/\r?\n/).includes(line)) return before;
+  return `${before}${before && !before.endsWith('\n') ? '\n' : ''}${line}`;
+}
+
+/** A merge establishes ownership of a PR, not completion of a whole cell. */
+export function decideGreenSweep(input: {
+  item: ChecklistItem;
+  candidate: GreenSweepCandidate;
+  candidateCount: number;
+  pr: GreenSweepPr | null;
+  ancestor: boolean | null;
+  hold: boolean | null;
+  repositoryMatches?: boolean | null;
+  ambiguousAcrossCells?: boolean;
+}): GreenSweepDecision {
+  const { item, candidate, pr } = input;
+  const mergeSha = pr?.mergeSha && /^[a-f0-9]{40}$/i.test(pr.mergeSha) ? pr.mergeSha : null;
+  const result = (verdict: GreenSweepVerdict, reason: string): GreenSweepDecision => {
+    const evidence = `GREEN-FROM-LEDGER: PR #${candidate.pr}${mergeSha ? ` merged ${mergeSha}` : ''} · ${verdict} · ${reason}`;
+    return { cell: item.id, pr: candidate.pr, mergeSha, source: candidate.source, verdict, reason,
+      evidence, existingEvidence: item.evidence ?? '', plannedEvidence: appendGreenSweepEvidence(item.evidence, evidence) };
+  };
+  if (item.status !== 'yellow' && item.status !== 'red') return result('skip', 'cell-not-yellow');
+  if (item.status === 'red') return result('skip', 'red-cell-requires-owner');
+  if (!pr || pr.number !== candidate.pr) return result('skip', 'pr-unreadable');
+  if (input.repositoryMatches === false) return result('skip', 'repository-mismatch');
+  if (input.repositoryMatches !== true) return result('record-only', 'repository-unreadable');
+  if (pr.state !== 'MERGED') return result('skip', `pr-${pr.state.toLowerCase()}`);
+  if (!mergeSha) return result('skip', 'merge-sha-unreadable');
+  if (input.ancestor === null) return result('record-only', 'origin-main-ref-unverified');
+  if (!input.ancestor) return result('skip', 'merge-sha-not-on-origin-main');
+  const explicitUrls = [...(item.evidence ?? '').matchAll(/https?:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/\d+\b/gi)]
+    .map((match) => match[0]);
+  if (explicitUrls.some((url) => /\/pull\/(\d+)\b/.exec(url)?.[1] === String(candidate.pr)
+    && url.replace(/\/+$/, '').toLowerCase() !== (pr.url ?? '').replace(/\/+$/, '').toLowerCase()))
+    return result('skip', 'evidence-pr-url-mismatch');
+  if (/보류|중단|정지|\bhold\b/i.test(`${item.title}\n${item.evidence ?? ''}`))
+    return result('skip', 'cell-stop-evidence');
+  if (input.hold === null) return result('record-only', 'hold-state-unreadable');
+  if (input.hold) return result('skip', 'traffic-hold');
+  if (input.candidateCount !== 1) return result('record-only', 'multiple-piece-prs');
+  if (input.ambiguousAcrossCells) return result('record-only', 'ambiguous-pr-across-cells');
+  if (candidate.ambiguousAcrossCards) return result('record-only', 'ambiguous-pr-across-cards');
+  if (/남은|나머지|후속|조각|분할|미착지|미병합|예정|계획|(?:착지|병합)\s*(?:실패|불가|아직|미완료|누락|못\s*함)|PR\s*#\d+\s*누락|추가\s*(?:작업|실물|검증|배선|조각|PR|필요)|(?:착지|실물|판정|검증|승인|운영)\s*대기|대기\s*(?:중|필요)|[1-9]차|(?:작업|검증|확인|운영|수리|배선)\s*필요|(?:일부|부분)(?:\s*범위(?:만)?)?\s*완료|잔여|미충족|미달|미완료|대체\s*후보/i.test(`${item.title}\n${item.evidence ?? ''}`))
+    return result('record-only', 'remaining-or-multiple-piece-evidence');
+  const verdictLines = [...(item.evidence ?? '').matchAll(/(?:^|\n)\s*(?:판정|결론|상태)\s*:\s*([^\n]+)/gi)];
+  if (verdictLines.some((match) => !/^(?:green|완료|충족)(?:$|[\s·,.;])/i.test(match[1] ?? '')))
+    return result('record-only', 'conflicting-cell-verdict-evidence');
+  if (candidate.source === 'evidence') {
+    const fullCellProof = /(?:^|\n)\s*(?:판정|결론|상태)\s*:\s*(?:green|완료|충족)(?:$|[\s·,.;])/i;
+    return fullCellProof.test(item.evidence ?? '')
+      ? result('green', 'explicit-cell-completion-evidence')
+      : result('record-only', 'cell-completion-not-explicit');
+  }
+  const card = candidate.card;
+  if (!card) return result('record-only', 'ambiguous-card-binding');
+  if (!card.checklistVersion) return result('record-only', 'card-version-unbound');
+  if (card.status !== 'done') return result('record-only', 'card-not-done');
+  if (card.postLand && (card.postLand.outcome !== 'complete' || card.postLand.remaining.length > 0))
+    return result('record-only', 'card-post-land-incomplete');
+  if (card.history.some((event) => event.event === 'closed-by-hand'))
+    return result('record-only', 'card-stop-evidence');
+  if (typeof card.pr === 'object' && pr.url && card.pr.url
+    && card.pr.url.replace(/\/+$/, '') !== pr.url.replace(/\/+$/, ''))
+    return result('record-only', 'card-pr-url-mismatch');
+  if (card.prTerminal?.state === 'CLOSED') return result('record-only', 'card-terminal-conflict');
+  return result('green', card.postLand?.outcome === 'complete' ? 'bound-card-complete' : 'bound-card-merged');
+}
+
+/** Every candidate emits one structured decision, including refusals. */
+export function observeGreenSweep(decision: GreenSweepDecision, log: typeof debug.log = debug.log.bind(debug)): void {
+  log('task-agent.green-sweep', decision.verdict,
+    { cell: decision.cell, pr: decision.pr, mergeSha: decision.mergeSha, reason: decision.reason });
+}

package/src/task-agent/land-worktree.ts

@@ -24,7 +24,7 @@ const defaultGit: GitRun = (cwd, args) => {
 
 export interface LandWorktreeInput { card: string; pr: number; head: string; branch: string | undefined; repoCwd: string; statePath: string }
 export type LandWorktreeRemoval = { removed: boolean; reason?: string; /** 이 호출이 만든 가지를 지웠나 — 만든 가지가 없으면 null. */ branchRemoved?: boolean | null };
-export interface LandWorktree { cwd: string; cleanup: () => LandWorktreeRemoval }
+export interface LandWorktree { cwd: string; cleanup: () => LandWorktreeRemoval; /** false means an existing owner's tree is borrowed, never removed. */ created?: boolean }
 
 export interface LandWorktreeDeps {
   git?: GitRun;
@@ -46,6 +46,14 @@ export function localHead(cwd: string, git: GitRun = defaultGit): string | null
   } catch { return null; }
 }
 
+/** cwd 의 현재 가지 — detached·조회 실패는 null. */
+export function localBranch(cwd: string, git: GitRun = defaultGit): string | null {
+  try {
+    const r = git(cwd, ['branch', '--show-current']);
+    return r.status === 0 && r.stdout.trim() ? r.stdout.trim() : null;
+  } catch { return null; }
+}
+
 async function defaultProvideDeps(worktree: string, sourceRoot: string): Promise<void> {
   const { spawnSync } = await import('node:child_process');
   const { provideCheckoutDependencies } = await import('../self-implement/host-regate.js');
@@ -71,6 +79,24 @@ function registered(git: GitRun, repoCwd: string, path: string): boolean | null
   return list.stdout.split('\n').some((line) => line.startsWith('worktree ') && real(line.slice('worktree '.length).trim()) === want);
 }
 
+/** A registered checkout of the exact PR branch. An unreadable/malformed registry is never treated as vacant. */
+function branchOwner(git: GitRun, repoCwd: string, branch: string): { path: string | null; reason?: string } {
+  let list: ReturnType<GitRun>;
+  try { list = git(repoCwd, ['worktree', 'list', '--porcelain']); }
+  catch { return { path: null, reason: 'git worktree registry unreadable (owner unknown)' }; }
+  if (list.status !== 0 || !list.stdout.trim()) return { path: null, reason: 'git worktree registry unreadable (owner unknown)' };
+  const entries = list.stdout.trim().split(/\n\s*\n/);
+  const owners: string[] = [];
+  for (const entry of entries) {
+    const lines = entry.split('\n');
+    const pathLine = lines.find(line => line.startsWith('worktree '));
+    if (!pathLine?.slice(9).trim()) return { path: null, reason: 'git worktree registry malformed (owner unknown)' };
+    if (lines.some(line => line === `branch refs/heads/${branch}`)) owners.push(pathLine.slice(9).trim());
+  }
+  if (owners.length > 1) return { path: null, reason: `PR branch ${branch} has multiple registered owners (owner unknown)` };
+  return { path: owners[0] ?? null };
+}
+
 /** 이 저장소의 git 공통 디렉터리(실경로) — 못 읽으면 null. */
 function commonDir(git: GitRun, repoCwd: string): string | null {
   const r = git(repoCwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
@@ -110,7 +136,7 @@ function removeWorktree(git: GitRun, repoCwd: string, path: string): { removed:
 }
 
 /** `created` — 트리를 만들었었나(모르면 null) · `removed` — 만들었다면 걷었나(만든 적 없거나 모르면 null). */
-export type LandWorktreeFailure = { reason: string; created: boolean | null; removed: boolean | null };
+export type LandWorktreeFailure = { reason: string; created: boolean | null; removed: boolean | null; kind?: 'worktree-conflict'; ownerPath?: string };
 
 /** PR 머리 트리를 만든다 — 못 만들면 이유 ⊕ 만들었다 걷었는지(관측용). 던지지 않는다. */
 export async function createLandWorktree(input: LandWorktreeInput, deps: LandWorktreeDeps = {}): Promise<LandWorktree | LandWorktreeFailure> {
@@ -119,10 +145,15 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
   const head = input.head.toLowerCase();
   const branch = input.branch;
   const fail = (reason: string, created: boolean | null = false, removed: boolean | null = null): LandWorktreeFailure => ({ reason, created, removed });
+  const conflict = (reason: string, ownerPath?: string): LandWorktreeFailure => ({ reason: `worktree-conflict: ${reason}`, created: false, removed: null, kind: 'worktree-conflict', ...(ownerPath ? { ownerPath } : {}) });
   if (!branch) return fail('PR head branch name unknown');
   if (!/^[0-9a-f]{40}$/.test(head)) return fail('PR head is not a full sha');
   // 지난 시도가 남긴 같은 자리는 먼저 걷는다(같은 PR·머리 · 재사용하지 않는다 — 상태를 모르는 트리에서 착지하지 않게).
-  if (existsSync(path) || registered(git, input.repoCwd, path) !== false) {
+  let atLandPath: boolean | null;
+  try { atLandPath = registered(git, input.repoCwd, path); }
+  catch { atLandPath = null; }
+  if (atLandPath === null) return conflict('git worktree list unreadable (owner unknown)');
+  if (existsSync(path) || atLandPath) {
     const stale = removeWorktree(git, input.repoCwd, path);
     if (!stale.removed) return fail(`stale land worktree could not be removed: ${stale.reason}`);
   }
@@ -135,9 +166,25 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
     return r.status === 0 ? r.stdout.trim().toLowerCase() : null;
   };
   const existingHead = branchHead();
-  if (existingHead && existingHead !== head) return fail(`local branch ${branch} exists at ${existingHead.slice(0, 12)} (not the PR head) — not overwriting it`);
   const mine = commonDir(git, input.repoCwd);
   if (!mine) return fail('git common directory unreadable');
+  const owner = branchOwner(git, input.repoCwd, branch);
+  if (owner.reason) return conflict(owner.reason);
+  if (owner.path) {
+    const path = owner.path;
+    // The registry is only a lead: validate the checkout itself immediately before handing it to pr land.
+    try {
+      if (commonDir(git, path) !== mine) return conflict(`owner ${path} repository identity unreadable or different`, path);
+      const current = git(path, ['branch', '--show-current']);
+      if (current.status !== 0 || current.stdout.trim() !== branch) return conflict(`owner ${path} branch is ${current.stdout.trim() || 'unknown'} (expected ${branch})`, path);
+      const actualHead = localHead(path, git);
+      if (actualHead?.toLowerCase() !== head) return conflict(`owner ${path} HEAD ${actualHead?.slice(0, 12) ?? 'unknown'} ≠ reviewed ${head.slice(0, 12)}`, path);
+      const status = git(path, ['status', '--porcelain']);
+      if (status.status !== 0 || status.stdout.trim()) return conflict(`owner ${path} is ${status.status !== 0 ? 'status unreadable' : `dirty: ${status.stdout.trim().split('\n').slice(0, 3).join(' · ').slice(0, 160)}`}`, path);
+    } catch { return conflict(`owner ${path} verification failed`, path); }
+    return { cwd: path, created: false, cleanup: () => ({ removed: false, reason: `borrowed owner ${path} — left untouched` }) };
+  }
+  if (existingHead && existingHead !== head) return fail(`local branch ${branch} exists at ${existingHead.slice(0, 12)} (not the PR head) — not overwriting it`);
   try {
     mkdirSync(dirname(path), { recursive: true });
     // 표지를 먼저 — 등록 전에 죽어도 다음 시도가 «우리 잔여»임을 확인하고 걷을 수 있게.
@@ -192,7 +239,7 @@ export async function createLandWorktree(input: LandWorktreeInput, deps: LandWor
   } catch (error) {
     return abort(`land worktree check threw: ${(error instanceof Error ? error.message : String(error)).slice(-200)}`);
   }
-  return { cwd: path, cleanup };
+  return { cwd: path, cleanup, created: true };
 }
 
 export function observeLandWorktree(data: { card: string; pr: number; head: string; created: boolean | null; removed: boolean | null; branchRemoved?: boolean | null; reason: string },

package/src/task-agent/live-move-history.ts

@@ -50,6 +50,7 @@ export function liveMoveEffect(input: Pick<LiveMoveHistoryInput, 'executorResult
   const result = input.result;
   if (!result) return LIVE_MOVE_EFFECT_UNKNOWN;
   if (!result.executed) return 'none — not executed';
+  if (result.kind === 'decision-card') return result.ok ? 'decision card raised' : 'raise failed';
   if (result.kind === 'review' && result.ok) return result.resultPath ? LIVE_REVIEW_EFFECT_PENDING : LIVE_REVIEW_EFFECT_REQUESTED;
   if (result.kind === 'land' && result.ok) return 'land reported ok by the executor (merge state not re-checked here) · merge sha not reported';
   if (result.kind === 'propose-green' && result.ok) return `green proposed · checklist ${checklistId ?? '-'} (checklist untouched)`;