elanous 0.2.35 → 0.2.37

package/src/task-agent/parent-host.ts

@@ -81,7 +81,7 @@ export function resolveParentHosts(config: ParentHostSetting | undefined, env: N
 }
 
 /** Capacity sample is read on the host before launch. Unknown or saturated capacity is not a positive weight. */
-export interface ParentHostCapacity { approvalHeadroom: number; load: number }
+export interface ParentHostCapacity { active: number; waiting: number; approvalHeadroom: number; load: number }
 
 export interface ParentHostPodFit {
   state: 'fits' | 'never-fits' | 'unmeasured';
@@ -127,26 +127,35 @@ export function readParentHostPodFit(target: ParentHostConfig, memoryLimit: stri
 }
 
 const CAPACITY_MARKER = '__ELANOUS_PARENT_CAPACITY__';
+const CAPACITY_ERROR_MARKER = '__ELANOUS_PARENT_CAPACITY_ERROR__';
 const APPROVAL_MARKER = '__ELANOUS_PARENT_APPROVALS__';
 const LOAD_MARKER = '__ELANOUS_PARENT_LOAD__';
+/** Best-effort macOS `ps` fallback; Linux/WSL uses argv boundaries below. */
+export const PARENT_HOST_ACTIVE_FILTER = String.raw`/^(([^ ]+\/)?(bun|node|nodejs) )?([^ ]+\/)?elanous(\.mjs)?( --config-dir [^ ]+)? harness (say|ask)( |$)/ && / --no-auto-merge( |$)/ && !/ --substrate local( |$)/ && !/^([^ ]+\/)?[^ ]*sh -c/`;
+/** Count exact Linux argv entries so Pod-local commands and goal text cannot masquerade as host parents. */
+export const PARENT_HOST_PROC_COUNT_SCRIPT = "count=0; proc_root=${1:-/proc}; for file in \"$proc_root\"/[0-9]*/cmdline; do [ -r \"$file\" ] || continue; argv=(); while IFS= read -r -d '' arg; do argv+=(\"$arg\"); done < \"$file\" 2>/dev/null || true; [ ${#argv[@]} -ge 3 ] || continue; program=\"${argv[0]##*/}\"; case \"$program\" in elanous|elanous.mjs) ;; bun|node|nodejs) script_match=0; for ((i=1; i<${#argv[@]}; i++)); do if [[ \"${argv[i]}\" == */elanous.mjs ]]; then script_match=1; break; fi; [[ \"${argv[i]}\" == harness ]] && break; done; [ \"$script_match\" -eq 1 ] || continue ;; *) continue ;; esac; harness=0; for ((i=0; i+1<${#argv[@]}; i++)); do if [[ \"${argv[i]}\" == harness && ( \"${argv[i+1]}\" == say || \"${argv[i+1]}\" == ask ) ]]; then harness=1; break; fi; done; [ \"$harness\" -eq 1 ] || continue; has_no_auto_merge=0; for arg in \"${argv[@]}\"; do [[ \"$arg\" == --no-auto-merge ]] && has_no_auto_merge=1; done; [ \"$has_no_auto_merge\" -eq 1 ] || continue; local_substrate=0; for ((i=0; i+1<${#argv[@]}; i++)); do if [[ \"${argv[i]}\" == --substrate && \"${argv[i+1]}\" == local ]]; then local_substrate=1; break; fi; done; [ \"$local_substrate\" -eq 1 ] || count=$((count+1)); done; printf '__ELANOUS_PARENT_CAPACITY__%s\\n' \"$count\""
 /** Recent admission decisions are the host's measured approval backlog, not an inferred process count. */
 export function readParentHostCapacity(target: ParentHostConfig, ssh: SshRunner = defaultSshRunner): ParentHostCapacity | null {
   const executable = remotePath(target.elanous ?? DEFAULT_REMOTE_ELANOUS);
   const configDir = remotePath(target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR);
-  const script = `parents=$(ps -Ao command) || exit 1; printf '%s\\n' "$parents" | awk '/[e]lanous.*harness (say|ask)/ { n++ } END { print "${CAPACITY_MARKER}" n+0 }'; `
+  const unavailable = (reason: string): null => { try { debug.log('task-agent.parent-host', 'capacity-unavailable', { host: target.host, reason }); } catch { /* fail-soft */ } return null; };
+  const processCount = `if [ -r /proc/self/cmdline ]; then if command -v bash >/dev/null 2>&1; then bash -c ${shellQuote(PARENT_HOST_PROC_COUNT_SCRIPT)} -- /proc; else printf "${CAPACITY_ERROR_MARKER}bash-unavailable\\n"; exit 1; fi; else parents=$(ps -Ao command) || exit 1; printf '%s\\n' "$parents" | awk '${PARENT_HOST_ACTIVE_FILTER} { n++ } END { print "${CAPACITY_MARKER}" n+0 }'; fi`;
+  const script = `${processCount}; `
     + `${executable} --config-dir ${configDir} logs --event admit-by-usage --since 5m --json --limit 1000 || exit 1; `
     + `printf '\\n${APPROVAL_MARKER}\\n'; `
     + `cpu=$(ps -Ao %cpu=) || exit 1; printf '%s\\n' "$cpu" | awk '{ total += $1 } END { printf "${LOAD_MARKER}%.3f\\n", total+0 }'; `
     + `cores=$(getconf _NPROCESSORS_ONLN 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null) || exit 1; printf '${LOAD_MARKER}cores=%s\\n' "$cores"`;
   try {
     const result = ssh(target.host, script, 15_000);
-    if (result.status !== 0) return null;
+    if (result.status !== 0) return unavailable(result.stdout.includes(`${CAPACITY_ERROR_MARKER}bash-unavailable`) ? 'bash-unavailable' : 'remote-command-failed');
     const activeMatch = new RegExp(`^${CAPACITY_MARKER}(\\d+)$`, 'm').exec(result.stdout);
     const boundary = result.stdout.indexOf(`\n${APPROVAL_MARKER}\n`);
     const logsStart = result.stdout.indexOf('\n');
     const cpuMatch = new RegExp(`^${LOAD_MARKER}([0-9]+(?:\\.[0-9]+)?)$`, 'm').exec(result.stdout);
     const coresMatch = new RegExp(`^${LOAD_MARKER}cores=(\\d+)$`, 'm').exec(result.stdout);
-    if (!activeMatch || activeMatch.index !== 0 || logsStart < 0 || boundary < logsStart || !cpuMatch || !coresMatch) return null;
+    if (!activeMatch || activeMatch.index !== 0) return unavailable('active-count-marker-missing');
+    if (logsStart < 0 || boundary < logsStart) return unavailable('approval-boundary-missing');
+    if (!cpuMatch || !coresMatch) return unavailable('load-marker-missing');
     const active = Number(activeMatch[1]);
     const cores = Number(coresMatch[1]);
     const cpu = Number(cpuMatch[1]);
@@ -172,23 +181,24 @@ export function readParentHostCapacity(target: ParentHostConfig, ssh: SshRunner
       decisions.set(data.runId, data.recommended as number);
     }
     const waiting = [...decisions.values()].filter((n) => n === 0).length;
-    return { approvalHeadroom: Math.max(0, capacity - active - waiting), load: Math.max(0, cpu / (cores * 100)) };
-  } catch { return null; }
+    return { active, waiting, approvalHeadroom: Math.max(0, capacity - active - waiting), load: Math.max(0, cpu / (cores * 100)) };
+  } catch { return unavailable('capacity-parse-failed'); }
 }
 
-/** Weighted rendezvous: stable per run, no shared counter or dependence on dispatch order. */
-export function orderParentHosts(targets: readonly ParentHostConfig[], runId: string, capacities: Readonly<Record<string, ParentHostCapacity | null>>): ParentHostConfig[] {
+/** Weighted rendezvous rank with evidence fields for launch-time observation. */
+export function rankParentHosts(targets: readonly ParentHostConfig[], runId: string, capacities: Readonly<Record<string, ParentHostCapacity | null>>): Array<{ target: ParentHostConfig; weight: number; score: number }> {
   return targets.map((target, index) => {
     const sample = capacities[target.host];
     const weight = sample && Number.isSafeInteger(sample.approvalHeadroom) && sample.approvalHeadroom > 0 && Number.isFinite(sample.load) && sample.load >= 0
       ? sample.approvalHeadroom / (1 + sample.load) : 0;
     const hash = createHash('sha256').update(`${runId}\0${target.host}`).digest();
     const fraction = (hash.readUIntBE(0, 6) + 1) / (2 ** 48 + 1);
-    return { target, index, score: weight > 0 ? -Math.log(fraction) / weight : Infinity };
-  }).sort((a, b) => a.score - b.score || a.index - b.index).map(({ target }) => target);
+    return { target, index, weight, score: weight > 0 ? -Math.log(fraction) / weight : Infinity };
+  }).sort((a, b) => a.score - b.score || a.index - b.index).map(({ target, weight, score }) => ({ target, weight, score }));
 }
 
-/** `$HOME/…` 은 원격 셸이 풀도록 따옴표 밖에 둔다 — 나머지는 shellQuote. */
+
+/** Keep `$HOME/...` outside quotes so the remote shell expands it; quote every other path. */
 function remotePath(path: string): string {
   return path.startsWith('$HOME/') ? `"$HOME"/${shellQuote(path.slice('$HOME/'.length))}` : shellQuote(path);
 }

package/src/task-agent/rejudge-on-head.ts

@@ -44,6 +44,7 @@ import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { remoteLedgerMirrorDir } from './parent-host.js';
 import { appendLandOrderRow, joinLandOrderRow } from './land-order-ledger.js';
 import { recordLiveMoveHistory } from './live-move-history.js';
+import { advanceLandedPieceMission } from './mission.js';
 import { runRepairCycle, type RepairLaunchRequest } from './repair-cycle.js';
 import { repairMustFixFromReview, repairReviewDigest } from './repair-review.js';
 import type { RepairCasOutcome, RepairCasRequest } from './repair-branch-cas.js';
@@ -101,6 +102,8 @@ export interface RejudgeDeps {
   notifyRepair?: (seat: string, body: string) => void;
   /** Shared new-launch budget for this `tasks rejudge --all` call. */
   repairBudget?: import('./repair-cycle.js').RepairTickBudget;
+  /** Verify a later PR head contains the harvested owner commit (read-only). */
+  ownerHarvestAncestor?: (cwd: string, owner: string, head: string) => boolean;
   /** One review request across all candidates in one --all tick; standalone card rejudge is uncapped. */
   reviewBudget?: { max: number; requested: number };
   /** One land or queue attempt across all candidates in one --all tick. */
@@ -112,6 +115,8 @@ export interface RejudgeDeps {
   readFile?: (path: string) => string;
   /** Verify a CLOSED component PR against the HQ train ledger and merged integration PR. */
   trainLanding?: (pr: number, cwd: string) => TrainLanding | null;
+  /** Confirmed merged component PR wakes successor pieces. */
+  advanceLandedPiece?: (pieceId: string, statePath: string) => Promise<unknown>;
 }
 
 /** PR binding alone does not mean a remote parent has stopped. Require its child edge and terminal ledger row. */
@@ -343,10 +348,11 @@ const catchUpFail = (reason: string, extra: Partial<CatchUpResult> = {}): CatchU
 /**
  * origin/main 을 PR 머리에 3-way merge(rerere 켬) 하고 일반 push 한다.
  * ⛔ rebase · force-push · reset · 남의 가지 파일째 checkout — 충돌이면 merge --abort.
+ * 이전 시도의 worktree 경로가 남았으면 새 경로로 한 번 더 시도한다. 남은 트리를 강제 제거하지 않는다.
  */
 export async function defaultCatchUpMain(request: CatchUpRequest, git: CatchUpGit = defaultCatchUpGit): Promise<CatchUpResult> {
   const repo = request.cwd;
-  const work = request.worktreePath ?? join(tmpdir(), `ta-catch-up-${request.pr}-${safe(request.head.slice(0, 12))}-${process.pid}`);
+  let work = request.worktreePath ?? join(tmpdir(), `ta-catch-up-${request.pr}-${safe(request.head.slice(0, 12))}-${process.pid}`);
   const gitRepo = (args: string[]) => git(repo, args);
   const gitWork = (args: string[]) => git(work, args);
   const fromBase = request.fromBase;
@@ -364,7 +370,12 @@ export async function defaultCatchUpMain(request: CatchUpRequest, git: CatchUpGi
     return catchUpFail(`fetched PR head ${(fetchedHead ?? '?').slice(0, 12)} ≠ ${request.head.slice(0, 12)}`, { fromBase, toBase });
   }
 
-  const added = gitRepo(['worktree', 'add', '--detach', work, request.head]);
+  let added = gitRepo(['worktree', 'add', '--detach', work, request.head]);
+  if (added.status !== 0 && /already exists|already registered|already used by worktree/i.test(added.stderr || added.stdout)) {
+    // 남은 경로가 살아 있는 다른 시도의 것일 수 있으므로 건드리지 않는다.
+    work = `${work}-retry-${randomUUID()}`;
+    added = gitRepo(['worktree', 'add', '--detach', work, request.head]);
+  }
   if (added.status !== 0) return catchUpFail(`worktree add failed: ${(added.stderr || added.stdout).trim().slice(-200)}`, { fromBase, toBase });
   const cleanup = () => { gitRepo(['worktree', 'remove', '--force', work]); };
 
@@ -492,7 +503,8 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   if ('reason' in found) return target('pr-unreadable', found.reason, pr, fromHead);
   const { cwd, view } = found;
   const toHead = view.head;
-  const eligible = !!reviews.length || adopted || (!!card.parentHost && (deps.remoteRunTerminal ?? remoteBoundRunTerminal)(card));
+  const harvest = pendingOwnerHarvest(card, pr);
+  const eligible = !!reviews.length || adopted || !!harvestReviewPending(card, pr) || (!!card.parentHost && (deps.remoteRunTerminal ?? remoteBoundRunTerminal)(card));
   const trustedTrain = view.state === 'CLOSED' && card.status === 'launched'
     ? (() => { try { return (deps.trainLanding ?? verifiedTrainLanding)(pr, cwd); } catch { return null; } })() : null;
   // An unreviewed or unproven remote card retains the old guard. Only verified train
@@ -509,11 +521,19 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   if (view.state === 'MERGED' || view.state === 'CLOSED') {
     const at = now().toISOString();
     const train = trustedTrain;
+    // TA-CARD-MERGE-RECONCILE — 사람이 손 병합한 실패 카드는 터미널 표시보다 먼저 실제 land 실행기로 정산한다.
+    // 정산이 성공하면 원장(status·hand-move 이력·merge sha 터미널)은 reconcile 이 이미 썼다 — 중복 터미널 쓰기 없이 판정으로 돌아간다.
+    if (view.state === 'MERGED' && card.status === 'failed' && deps.liveMoves.has('propose-land')) {
+      const landed = await executeLiveLand(card, pr, { runId: card.runId ?? null, cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
+      if (landed.ok && landed.executed) return target('landed-by-hand', landed.detail, pr, fromHead, toHead);
+    }
     updateTaskCard(statePath, card.id, (current) => {
       if (!current || cardPrNumber(current) !== pr || typeof current.pr !== 'object' || current.pr.url !== url) return undefined;
       const previous = boundPrTerminal(current);
       const alreadyLanded = train && current.trainLanding?.componentPr === pr
         && current.trainLanding.integrationPr === train.integrationPr && current.trainLanding.mergeSha === train.mergeSha;
+      // 손 병합 정산이 남긴 merge sha 터미널은 다음 틱이 가지 머리로 덮어쓰지 않는다(landed/landed-by-hand 는 이미 종결 상태).
+      if (previous && (current.status === 'landed' || current.status === 'landed-by-hand')) return undefined;
       if (previous?.state === view.state && previous.head === toHead && (!train || alreadyLanded) && (!train || current.status === 'done')) return undefined;
       return {
         ...current,
@@ -524,10 +544,33 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
           : { pr, url, head: toHead, state: view.state as 'MERGED' | 'CLOSED', at },
       };
     });
+    if (view.state === 'MERGED' || train) {
+      try { await (deps.advanceLandedPiece ?? ((pieceId, path) => advanceLandedPieceMission(pieceId, { statePath: path })))(card.id, statePath); }
+      catch (error) { try { log('task-agent', 'mission-auto-advance-error', { card: card.id, pr, error: String(error).slice(0, 250) }); } catch { /* fail-soft */ } }
+    }
     return train ? target('landed-via-train', `PR #${pr} via train #${train.integrationPr} merge ${train.mergeSha}`, pr, fromHead, toHead)
       : target('pr-not-open', `PR #${pr} is ${view.state}`, pr, fromHead, toHead);
   }
   if (view.state !== 'OPEN') return target('pr-not-open', `PR #${pr} is ${view.state}`, pr, fromHead, toHead);
+  if (harvest) {
+    const ancestor = deps.ownerHarvestAncestor ?? ((repo: string, owner: string, head: string) => {
+      const result = spawnSync('git', ['merge-base', '--is-ancestor', owner, head], { cwd: repo, encoding: 'utf8', timeout: 10_000 });
+      return result.status === 0;
+    });
+    let reached = sameHead(toHead, harvest.head);
+    if (!reached) { try { reached = ancestor(cwd, harvest.head, toHead); } catch { reached = false; } }
+    if (!reached) {
+      emit({ card: card.id, pr, fromHead, toHead, step: 'review', decision: 'awaiting-harvest',
+        reason: `PR #${pr} head ${toHead.slice(0, 12)} awaits owner-worktree-commit ${harvest.head.slice(0, 12)} · next: wait for harvest` }, false);
+      return outcomes;
+    }
+    updateTaskCard(statePath, card.id, current => current && cardPrNumber(current) === pr
+      && typeof current.pr === 'object' && current.pr.url === url && pendingOwnerHarvest(current, pr)?.head === harvest.head
+      && !current.history.some(entry => entry.event === 'review-harvest-reached' && entry.pr === pr
+        && entry.runId === current.runId && entry.head && sameHead(entry.head, toHead))
+      ? { ...current, history: [...current.history, { at: now().toISOString(), event: 'review-harvest-reached',
+        pr, head: toHead, ...(current.runId ? { runId: current.runId } : {}), detail: `PR #${pr} head reached owner-worktree-commit · next: review` }] } : undefined);
+  }
   // An explicitly rejudged PR can be reopened. Clear the old marker before normal head judgement.
   if (boundPrTerminal(card)) {
     updateTaskCard(statePath, card.id, (current) => current && cardPrNumber(current) === pr && typeof current.pr === 'object' && current.pr.url === url
@@ -537,6 +580,26 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   const step = (s: RejudgeStep, decision: string, reason: string, record: boolean, extra: Partial<RejudgeOutcome> = {}) =>
     emit({ card: card!.id, pr, fromHead, toHead, step: s, decision, reason, ...extra }, record);
   const requestReview = async (candidate: TaskCard, reason: string, forceNewReview = false): Promise<void> => {
+    // The head used for this decision may have moved while the card was being updated.
+    // Never request a review of a new head until it is verified against the owner commit.
+    if (harvest) {
+      let fresh: PrHeadView | null;
+      try { fresh = await (live.prHead ?? defaultPrHead)(pr, cwd); } catch { fresh = null; }
+      if (!fresh || fresh.state !== 'OPEN' || !fresh.url || !sameUrl(fresh.url, url)) {
+        step('review', 'awaiting-harvest', `PR #${pr} fresh head unavailable · next: wait for harvest`, false);
+        return;
+      }
+      let reached = sameHead(fresh.head, harvest.head);
+      if (!reached) {
+        try { reached = (deps.ownerHarvestAncestor ?? ((repo: string, owner: string, head: string) =>
+          spawnSync('git', ['merge-base', '--is-ancestor', owner, head], { cwd: repo, encoding: 'utf8', timeout: 10_000 }).status === 0))(cwd, harvest.head, fresh.head); }
+        catch { reached = false; }
+      }
+      if (!reached) {
+        step('review', 'awaiting-harvest', `PR #${pr} head ${fresh.head.slice(0, 12)} awaits owner-worktree-commit ${harvest.head.slice(0, 12)} · next: wait for harvest`, false);
+        return;
+      }
+    }
     const budget = deps.reviewBudget;
     if (budget && budget.requested >= budget.max) {
       step('review', 'tick-cap', `review request cap ${budget.max} reached — next tick`, false);
@@ -545,9 +608,12 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     // Reserve before awaiting the worker so another candidate cannot launch a second request.
     if (budget) budget.requested++;
     const before = { reviewRequests: candidate.reviewRequests, landAttempts: candidate.landAttempts };
-    const result = await executeLiveReview(candidate, pr, { runId: candidate.runId ?? null, stopReason: reason, cwd, forceNewReview }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
+    const result = await executeLiveReview(candidate, pr, { runId: candidate.runId ?? null, stopReason: reason, cwd, forceNewReview,
+      ...(harvest ? { ownerHarvestHead: harvest.head, ...(deps.ownerHarvestAncestor ? { ownerHarvestAncestor: deps.ownerHarvestAncestor } : {}) } : {}) },
+      { ...live, ...(deps.log ? { log: deps.log } : {}) });
     recordMove(statePath, candidate.id, candidate.runId, 'review', result, pr, before, now, deps.log);
-    step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
+    step('review', harvest && !result.executed && result.detail.includes('awaits owner-worktree-commit') ? 'awaiting-harvest'
+      : result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
   };
 
   // Adoption is a first judgement for the current head, even when the implementation run
@@ -923,6 +989,21 @@ function recordMove(statePath: string, cardId: string, runId: string | undefined
   } catch { /* recordLiveMoveHistory 는 스스로 관측한다 */ }
 }
 
+function harvestReviewPending(card: TaskCard, pr: number): boolean {
+  if (card.status !== 'launched' || typeof card.pr !== 'object' || card.pr.number !== pr || !card.pr.url || !card.runId) return false;
+  const latest = card.history.filter(entry => (entry.event === 'review-skipped-harvest' || entry.event === 'review-harvest-reached')
+    && entry.pr === pr && typeof entry.head === 'string' && /^[a-f0-9]{40}$/i.test(entry.head)
+    && entry.runId === card.runId).at(-1);
+  return !!latest && !(card.reviewRequests ?? []).some(entry => entry.pr === pr && sameHead(entry.head, latest.head!));
+}
+
+function pendingOwnerHarvest(card: TaskCard, pr: number): { head: string } | undefined {
+  if (!harvestReviewPending(card, pr)) return undefined;
+  const latest = card.history.filter(entry => entry.event === 'review-skipped-harvest' && entry.pr === pr
+    && entry.runId === card.runId && typeof entry.head === 'string' && /^[a-f0-9]{40}$/i.test(entry.head)).at(-1);
+  return latest?.effect === 'wait' ? { head: latest.head! } : undefined;
+}
+
 /** 재판정 대상 카드 — 기존 리뷰 또는 HQ 가 종결 원장을 검증할 원격 부모 카드. */
 export function rejudgeCandidates(tasks: Readonly<Record<string, TaskCard>>, opts: {
   now?: Date; maxAgeHours?: number; onAgeSkip?: (card: TaskCard, ageHours: number | null) => void;
@@ -934,6 +1015,7 @@ export function rejudgeCandidates(tasks: Readonly<Record<string, TaskCard>>, opt
   return Object.values(tasks).filter((card) => {
     const pr = cardPrNumber(card);
     const eligible = pr !== undefined && !boundPrTerminal(card) && ((card.reviewRequests ?? []).some((entry) => entry.pr === pr)
+      || (pr !== undefined && harvestReviewPending(card, pr))
       || (card.status === 'launched' && card.taLand === true && ((!!card.parentHost && !!card.runId && !!card.runChildId)
         || (card.adoptedPr?.pr === pr && typeof card.pr === 'object' && !!card.pr.url && sameUrl(card.adoptedPr.url, card.pr.url)))));
     if (!eligible) return false;

package/src/task-agent/repair-cycle.ts

@@ -10,26 +10,38 @@ import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { checklistHistory, listChecklist, parseOwner } from '../release-loop/checklist.js';
 import { applyRepairBundle, type RepairCasOutcome, type RepairCasRequest } from './repair-branch-cas.js';
-import { repairNextMove } from './repair-next-move.js';
+import { pairMoveId, repairNextMove } from './repair-next-move.js';
+import type { SupervisorGoalDeficit } from '../self-implement/goal-supervisor-fill.js';
+import { loadRunLedger, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { parseRepairWorkerResult } from './repair-worker.js';
 import { TASK_SEATS, readTaskCard, updateTaskCard, type TaskCard, type TaskChildLlm, type TaskSeat } from './task-hand.js';
 
 const WAIT_MS = 90 * 60_000;
+const ESCALATE_MS = 6 * 60 * 60_000;
+const ALERT_CLAIM_STALE_MS = 10 * 60_000;
 const safe = (value: string) => value.replace(/[^A-Za-z0-9._-]/g, '_');
 
 export interface RepairLaunchRequest {
   card: string; pr: number; head: string; repo: string; resultPath: string;
   goalFile: string; runId: string; model: TaskChildLlm; seat?: string;
+  parentRoleLlm?: string[];
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — 이 발사를 고른 next-move 결정의 수 id(결정·graph-edge-taken 과 같은 값). */
+  moveId: string;
 }
 
 export interface RepairCycleInput {
   card: TaskCard; statePath: string; repo: string; pr: number; head: string; branch: string;
   mustFix: readonly string[]; liveMoves: ReadonlySet<string>; now: Date;
+  supervisorDeficit?: SupervisorGoalDeficit;
+  supervisorResult?: import('../self-implement/goal-supervisor-fill.js').SupervisorGoalFillResult;
+  readRunLedger?: (runId: string) => RunLedgerEntry[] | null;
   readFile?: (path: string) => string;
   request?: (input: RepairLaunchRequest) => Promise<void>;
   apply?: (input: RepairCasRequest) => RepairCasOutcome;
   notify?: (seat: string, body: string) => void;
-  observeLaunch?: (move: string, runId: string) => void;
+  observeLaunch?: (move: string, runId: string, moveId: string) => void;
+  /** 시험 seam — next-move 결정의 수 id 발급기(기본 `mintMoveId`). 결정 순간 한 번만 불린다. */
+  mintMoveId?: () => string;
   resolveOwner?: (card: TaskCard) => RepairOwner;
   /** Shared only by one `tasks rejudge --all` invocation; a single-card rejudge has no cap. */
   repairBudget?: RepairTickBudget;
@@ -96,23 +108,21 @@ export async function repairModelAvailability(readInputs: () => Promise<Pick<Bud
 export function alternateRepairModel(card: TaskCard, availability: RepairModelAvailability = { codexSubscription: false, grokSubscription: false }): { from: string; to: TaskChildLlm } {
   const last = card.repairs?.at(-1);
   const from = last?.toModel ?? (card.childLlm ? `${card.childLlm.provider}/${card.childLlm.model}` : 'unknown');
-  const glm: TaskChildLlm = { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3' };
+  // The Pod's named ZAI subscription is the primary GLM route. A failed
+  // glm-5.3 repair must never be retried with the smaller flash model.
+  const glm: TaskChildLlm = { provider: 'glm', model: 'glm-5.3' };
   const sol: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-sol' };
   const grok: TaskChildLlm = { provider: 'grok', model: 'grok-4.6' };
-  const luna: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-luna' };
   const tier = card.tier ?? '중';
   const pr = typeof card.pr === 'number' ? card.pr : card.pr?.number;
   const mixEven = ((pr ?? [...card.id].reduce((sum, ch) => sum + ch.charCodeAt(0), 0)) % 2) === 0;
   let to: TaskChildLlm;
-  if (tier === '특') to = sol;
+  if (tier === '특' || (last && from.includes('gpt-6-sol'))) to = sol;
+  else if (last && from.includes('grok-4.6')) to = grok;
   else if (tier === '상' && availability.codexSubscription && mixEven && !from.includes('gpt-6-sol')) to = sol;
-  else if (tier === '상') to = availability.grokSubscription && from.includes('glm') ? grok
-    : from.includes('glm-5.3-flash') ? glm
-    : from.includes('glm-5.3') ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
-  else if (tier === '하') to = from.includes('glm-5.3-flash') ? luna : from.includes('glm-5.3')
-    ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
-  else to = from.includes('glm-5.3-flash') ? glm : from.includes('glm-5.3')
-    ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
+  else if (tier === '상') to = availability.grokSubscription && from.includes('glm') ? grok : glm;
+  else if (last && from.includes('gpt-6-luna')) to = { provider: 'openai-codex', model: 'gpt-6-luna' };
+  else to = glm;
   return { from, to };
 }
 
@@ -130,7 +140,8 @@ export async function defaultRequestRepair(input: RepairLaunchRequest): Promise<
     '--card', input.card, '--pr', String(input.pr), '--head', input.head, '--repo', input.repo,
     '--out', input.resultPath, '--goal-file', input.goalFile, '--run-id', input.runId,
     '--model-provider', input.model.provider, '--model-id', input.model.model,
-    ...(input.seat ? ['--seat', input.seat] : [])];
+    ...(input.parentRoleLlm ?? []).flatMap((value) => ['--role-llm', value]),
+    ...(input.seat ? ['--seat', input.seat] : []), '--move-id', input.moveId];
   await spawnDetachedConfirmed(spawn as never, process.execPath, args, undefined, input.repo);
 }
 
@@ -176,9 +187,59 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     let text: string | null = null;
     try { text = read(latest.resultPath); } catch { /* worker still running */ }
     const result = text === null ? null : parseRepairWorkerResult(text, pr, latest.head, latest.runId);
-    if (!result && now.getTime() - Date.parse(latest.at) < WAIT_MS)
-      return { decision: 'repair-pending', reason: `repair run ${latest.runId} pending` };
-    let detail = result?.reason ?? 'repair worker produced no valid result before timeout';
+    if (!result) {
+      const ageMs = now.getTime() - Date.parse(latest.at);
+      const overdue = ageMs >= WAIT_MS;
+      // Pod admission plus the child deadline can exceed 90 minutes. A
+      // missing receipt is uncertainty, never evidence that the worker failed.
+      if (overdue) {
+        const failureType = text === null ? 'receipt-missing' : 'receipt-invalid';
+        const detail = JSON.stringify({ failureType, model: latest.toModel, resultPath: latest.resultPath });
+        let overdueRecorded = false;
+        try { updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === latest.runId && entry.status === 'requested')
+          && !current.history?.some((entry) => entry.event === 'repair-receipt-overdue' && entry.runId === latest.runId)
+          ? (overdueRecorded = true, { ...current, history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-receipt-overdue',
+            pr, head: latest.head, runId: latest.runId, resultPath: latest.resultPath, detail }] }) : undefined);
+        } catch { /* an observation failure cannot consume a repair attempt */ }
+        if (overdueRecorded) try { debug.log('task-agent', 'repair-receipt-overdue', { card: card.id, pr, head: latest.head,
+          runId: latest.runId, failureType, model: latest.toModel, resultPath: latest.resultPath }); }
+        catch { /* diagnostics cannot consume a repair attempt */ }
+        if (ageMs >= ESCALATE_MS) {
+          let claimed = false;
+          try { updateTaskCard(statePath, card.id, (current) => {
+            const lastAlert = current?.history?.filter((entry) => entry.runId === latest.runId
+              && entry.event.startsWith('repair-receipt-alert-')).at(-1);
+            const staleClaim = lastAlert?.event === 'repair-receipt-alert-claimed'
+              && now.getTime() - Date.parse(lastAlert.at) >= ALERT_CLAIM_STALE_MS;
+            if (!current?.repairs?.some((entry) => entry.runId === latest.runId && entry.status === 'requested')
+              || lastAlert && lastAlert.event !== 'repair-receipt-alert-failed' && !staleClaim) return undefined;
+            claimed = true;
+            return { ...current, history: [...(current.history ?? []), { at: now.toISOString(),
+              event: 'repair-receipt-alert-claimed', pr, head: latest.head, runId: latest.runId,
+              resultPath: latest.resultPath, detail }] };
+          }); }
+          catch { /* the next tick can retry the alert claim */ }
+          if (claimed) {
+            const owner = (input.resolveOwner ?? resolveRepairOwner)(card);
+            let alertEvent = 'repair-receipt-alert-sent';
+            let alertDetail = detail;
+            try {
+              if (!owner.seat) throw new Error(`repair receipt owner unavailable: ${owner.reason ?? 'unknown'}`);
+              (input.notify ?? defaultNotify)(owner.seat, `repair receipt overdue: card ${card.id} PR #${pr} run ${latest.runId} · ${detail} · inspect worker/Pod terminal evidence before hand decision`);
+            } catch (error) {
+              alertEvent = 'repair-receipt-alert-failed';
+              alertDetail = `${detail} · ${String(error).slice(0, 200)}`;
+            }
+            try { updateTaskCard(statePath, card.id, (current) => current?.history?.some((entry) => entry.event === 'repair-receipt-alert-claimed' && entry.runId === latest.runId)
+              ? { ...current, history: [...current.history, { at: now.toISOString(), event: alertEvent, pr,
+                head: latest.head, runId: latest.runId, resultPath: latest.resultPath, detail: alertDetail }] } : undefined); }
+            catch { /* the claim still prevents duplicate owner messages */ }
+          }
+        }
+      }
+      return { decision: 'repair-pending', reason: `repair run ${latest.runId} ${overdue ? 'receipt overdue' : 'pending'} · ${latest.resultPath}` };
+    }
+    let detail = result.reason ?? 'repair worker failed';
     let applied: RepairCasOutcome | null = null;
     let claimedThisCycle = false;
     if (result?.ok && result.artifactDir && result.result) {
@@ -214,6 +275,15 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       }
     }
     const status = applied?.ok ? 'applied' : applied?.unconfirmed ? 'unconfirmed' : 'failed';
+    // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 결과 파일의 수 id 를 카드(발사 순간 적은 값)와 짝짓는다. 못 짝지으면 관측만(소비는 그대로).
+    const pairing = pairMoveId(latest.moveId, result.moveId);
+    if (pairing.kind === 'unpaired') try { debug.log('task-agent', 'move-id-unpaired', { card: card.id, pr, head: latest.head,
+      runId: latest.runId, source: 'result-file', expected: pairing.expected, observed: pairing.observed }); } catch { /* fail-soft */ }
+    const pairedMoveId = pairing.kind === 'paired' ? { moveId: pairing.moveId } : {};
+    try { debug.log('task-agent', 'repair-attempt-result', { card: card.id, pr, head: latest.head,
+      runId: latest.runId, failureType: status === 'applied' || status === 'unconfirmed' ? null : result.ok ? 'artifact-or-cas' : 'worker',
+      model: latest.toModel, resultPath: latest.resultPath, artifactDir: result.artifactDir ?? null, status, detail });
+    } catch { /* diagnostics cannot change the result */ }
     try {
       updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === latest.runId
         && (entry.status === 'requested' || (claimedThisCycle && entry.status === 'unconfirmed' && entry.commit === result?.result?.commit)))
@@ -222,7 +292,7 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
             bundleSha256: result.result.bundleSha256, bundlePath: join(resolve(result.artifactDir!), 'commit.bundle') } : {}),
             ...(applied?.ok ? { commit: applied.toHead } : {}) } : entry),
           history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-result', pr, head: latest.head,
-            runId: latest.runId, effect: status, detail }] } : undefined);
+            runId: latest.runId, effect: status, detail, ...pairedMoveId }] } : undefined);
     } catch (error) { return { decision: 'repair-pending', reason: `repair card write failed after CAS: ${String(error).slice(-200)}` }; }
     const recorded = readTaskCard(card.id, statePath)?.repairs?.find((entry) => entry.runId === latest.runId)?.status === status;
     return recorded ? { decision: applied?.ok ? 'repair-applied' : applied?.unconfirmed ? 'repair-pending' : 'repair-failed', reason: detail,
@@ -231,14 +301,52 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
   }
   if (latest?.status === 'applied' && latest.head.toLowerCase() === head.toLowerCase())
     return { decision: 'repair-pending', reason: `repair pushed; await PR head ${latest.commit?.slice(0, 12) ?? '?'}` };
+  const failedAttempts = attempts.filter((entry) => entry.status === 'failed');
+  let supervisorDeficit = input.supervisorDeficit;
+  let supervisorResult = input.supervisorResult;
+  if (!supervisorDeficit && card.runId) {
+    try {
+      const rows = (input.readRunLedger ?? loadRunLedger)(card.runId);
+      const recent = rows?.slice().reverse();
+      const latest = recent?.find((row) => row.event === 'goal-slot-fill' || row.event === 'supervisor-report-deficit');
+      const lastFill = recent?.find((row) => row.event === 'goal-slot-fill');
+      const lastDeficit = recent?.find((row) => row.event === 'supervisor-report-deficit');
+      const terminalClassification = lastDeficit?.data.classification;
+      const terminalReport = latest === lastDeficit && terminalClassification !== null && typeof terminalClassification === 'object'
+        && (terminalClassification as { classification?: unknown }).classification === 'report-deficit';
+      if (lastDeficit && (terminalReport || lastFill && latest === lastFill
+        && lastFill.data.result !== 'filled' && lastFill.data.result !== 'already-filled'
+        && lastFill.data.round === lastDeficit.data.round)
+        && lastDeficit.runId === card.runId && (terminalReport || lastFill?.runId === card.runId)
+        && typeof lastDeficit.data.evidenceId === 'string' && typeof lastDeficit.data.previousEvidence === 'string'
+        && typeof lastDeficit.data.round === 'number'
+        && (lastDeficit.data.kind === 'unmeasured' || lastDeficit.data.kind === 'unwired')) {
+        supervisorResult = terminalReport ? 'unverifiable' : lastFill?.data.result === 'rejected' ? 'rejected' : 'unverifiable';
+        supervisorDeficit = { evidenceId: lastDeficit.data.evidenceId, previousEvidence: lastDeficit.data.previousEvidence,
+          round: lastDeficit.data.round, kind: lastDeficit.data.kind,
+          ...(typeof lastDeficit.data.gateLog === 'string' ? { gateLog: lastDeficit.data.gateLog } : {}) };
+      }
+    } catch { /* unreadable ledger is not evidence of an unwired goal */ }
+  }
   const judged = repairNextMove({ pr, head, branch, mustFix: input.mustFix,
-    priorNarrowAttempts: attempts.filter((entry) => entry.move === 'narrow-relaunch' || entry.move === 'salvage-relaunch').length,
-    priorAlternativeAttempts: attempts.filter((entry) => entry.move === 'alternative').length });
+    ...(supervisorDeficit ? { supervisorDeficit } : {}),
+    ...(supervisorResult ? { supervisorResult } : {}),
+    priorNarrowAttempts: failedAttempts.filter((entry) => entry.move === 'narrow-relaunch' || entry.move === 'salvage-relaunch').length,
+    priorAlternativeAttempts: failedAttempts.filter((entry) => entry.move === 'alternative').length },
+    input.mintMoveId ? { mintMoveId: input.mintMoveId } : {});
+  if (judged.kind === 'grounding') {
+    const reason = `${judged.action} · evidence ${judged.supervisorDeficit.evidenceId}`;
+    updateTaskCard(statePath, card.id, (current) => current && !current.history?.some((entry) =>
+      entry.event === 'repair-grounding' && entry.runId === card.runId && entry.detail === reason)
+      ? { ...current, history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-grounding',
+        runId: card.runId, pr, head, detail: reason }] } : undefined);
+    return { decision: 'would-repair', reason };
+  }
   if (judged.kind === 'stop') {
-    if (attempts.length >= 2) {
-      const detail = `수리 수렴 실패: PR #${pr} head ${head.slice(0, 12)} · ${attempts.length}회 재발사 · ${judged.reason}`;
+    if (failedAttempts.length >= 2) {
+      const detail = `수리 수렴 실패: PR #${pr} head ${head.slice(0, 12)} · 실패 ${failedAttempts.length}회 · ${judged.reason}`;
       updateTaskCard(statePath, card.id, (current) => {
-        if (!current || current.status !== 'launched' || (current.repairs ?? []).filter((entry) => entry.pr === pr).length < 2) return undefined;
+        if (!current || current.status !== 'launched' || (current.repairs ?? []).filter((entry) => entry.pr === pr && entry.status === 'failed').length < 2) return undefined;
         return { ...current, status: 'failed', history: [...(current.history ?? []),
           { at: now.toISOString(), event: 'repair-convergence-failed', pr, head, detail }] };
       });
@@ -281,10 +389,48 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       requested: input.repairBudget.requested, capped: input.repairBudget.capped, move: judged.judgement.move }); } catch { /* fail-soft */ }
     return { decision: 'would-repair', reason };
   }
+  const lastModel = latest?.toModel ?? '';
+  const needsSubscriptionCheck = card.tier === '상' || card.tier === '특'
+    || lastModel.includes('gpt-6-sol') || lastModel.includes('grok-4.6');
+  const availability = input.modelAvailability ?? (needsSubscriptionCheck
+    ? await repairModelAvailability(input.readBudgetInputs) : { codexSubscription: false, grokSubscription: false });
+  if (latest?.status === 'failed' && (lastModel.includes('gpt-6-sol') && !availability.codexSubscription
+    || lastModel.includes('grok-4.6') && !availability.grokSubscription)) {
+    const reason = `repair model ${lastModel} subscription unavailable; retry deferred without downgrade`;
+    try { debug.log('task-agent', 'repair-model-unavailable', { card: card.id, pr, head,
+      failureType: 'subscription-unavailable', model: lastModel, resultPath: latest.resultPath }); } catch { /* fail-soft */ }
+    if (now.getTime() - Date.parse(latest.at) >= ESCALATE_MS) {
+      let alertClaimed = false;
+      try { updateTaskCard(statePath, card.id, (current) => {
+        const lastAlert = current?.history?.filter((entry) => entry.runId === latest.runId
+          && entry.event.startsWith('repair-model-alert-')).at(-1);
+        const staleClaim = lastAlert?.event === 'repair-model-alert-claimed'
+          && now.getTime() - Date.parse(lastAlert.at) >= ALERT_CLAIM_STALE_MS;
+        if (!current?.repairs?.some((entry) => entry.runId === latest.runId && entry.status === 'failed')
+          || lastAlert && lastAlert.event !== 'repair-model-alert-failed' && !staleClaim) return undefined;
+        alertClaimed = true;
+        return { ...current, history: [...(current.history ?? []), { at: now.toISOString(),
+          event: 'repair-model-alert-claimed', pr, head: latest.head, runId: latest.runId,
+          resultPath: latest.resultPath, detail: reason }] };
+      }); } catch { /* keep the failed repair eligible for a later tick */ }
+      if (alertClaimed) {
+        let event = 'repair-model-alert-sent';
+        let detail = reason;
+        try { (input.notify ?? defaultNotify)(owner.seat,
+          `repair model unavailable >6h: card ${card.id} PR #${pr} run ${latest.runId} · ${reason} · inspect subscription or hand off`); }
+        catch (error) { event = 'repair-model-alert-failed'; detail = `${reason} · ${String(error).slice(0, 200)}`; }
+        try { updateTaskCard(statePath, card.id, (current) => current?.history?.some((entry) => entry.event === 'repair-model-alert-claimed'
+          && entry.runId === latest.runId) ? { ...current, history: [...current.history, { at: now.toISOString(), event,
+            pr, head: latest.head, runId: latest.runId, resultPath: latest.resultPath, detail }] } : undefined); }
+        catch { /* a stale claim is retried on a later tick */ }
+      }
+    }
+    return { decision: 'would-repair', reason };
+  }
   const next = attempts.length + 1;
   const runId = mintRunId();
-  const availability = input.modelAvailability ?? (card.tier === '특' || card.tier === '중' || card.tier === '하'
-    ? { codexSubscription: false, grokSubscription: false } : await repairModelAvailability(input.readBudgetInputs));
+  // 결정 순간 만든 수 id — 아래 발사·카드·관측이 «이 값»만 쓴다(다시 만들지 않는다).
+  const moveId = judged.moveId;
   const { from, to } = alternateRepairModel(card, availability);
   const resultPath = repairResultPath(statePath, card.id, pr, head, next, runId);
   const goalFile = resultPath.replace(/\.json$/, '.goal.txt');
@@ -296,14 +442,15 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     if (!current || current.status !== 'launched' || (current.repairs ?? []).length !== (card.repairs ?? []).length) return undefined;
     claimed = true;
     return { ...current, repairs: [...(current.repairs ?? []), { pr, head, branch, at: now.toISOString(),
-      move: judged.judgement.move, runId, resultPath, fromModel: from, toModel: `${to.provider}/${to.model}`, status: 'requested' }],
+      move: judged.judgement.move, moveId, runId, resultPath, fromModel: from, toModel: `${to.provider}/${to.model}`, status: 'requested' }],
       history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-launched', pr, head, runId,
-        effect: judged.judgement.move, detail: `source pr:${pr} · owner ${owner.seat} via ${owner.source} · must-fix ${input.mustFix.length} · childLlm ${from} → ${to.provider}/${to.model}` }] };
+        effect: judged.judgement.move, moveId, detail: `source pr:${pr} · owner ${owner.seat} via ${owner.source} · must-fix ${input.mustFix.length} · childLlm ${from} → ${to.provider}/${to.model}` }] };
   });
   if (!claimed) return { decision: 'repair-pending', reason: 'another tick claimed repair launch' };
   try {
     await (input.request ?? defaultRequestRepair)({ card: card.id, pr, head, repo, resultPath, goalFile,
-      runId, model: to, seat: owner.seat });
+      runId, model: to, seat: owner.seat, moveId,
+      ...(card.parentRoleLlm?.length ? { parentRoleLlm: card.parentRoleLlm } : {}) });
     if (input.repairBudget) input.repairBudget.requested++;
   } catch (error) {
     const reason = `repair launch failed: ${error instanceof Error ? error.message : String(error)}`;
@@ -322,18 +469,18 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     try { debug.log('task-agent', 'repair-role-llm-observation-failed', { card: card.id, pr, head, runId, error: String(error) }); } catch { /* fail-soft */ }
   }
   try {
-    if (input.observeLaunch) input.observeLaunch(judged.judgement.move, runId);
+    if (input.observeLaunch) input.observeLaunch(judged.judgement.move, runId, moveId);
     else {
       passJourneyNode('next-move', { provenance: 'task-agent-repair', outcome: judged.judgement.move, runId,
-        data: { card: card.id, source: `pr:${pr}`, pr, head, branch, mustFix: input.mustFix } });
-      recordJourneyEdge(judged.route, 'dispatch');
+        data: { card: card.id, source: `pr:${pr}`, pr, head, branch, mustFix: input.mustFix, moveId } });
+      recordJourneyEdge(judged.route, 'dispatch', undefined, { moveId });
     }
   } catch (error) {
     const detail = `repair observation failed after worker launch: ${error instanceof Error ? error.message : String(error)}`;
     try { updateTaskCard(statePath, card.id, (current) => current
       ? { ...current, history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-observation-failed', pr, head, runId, detail }] } : undefined); }
     catch { /* launch remains requested even if its diagnostic cannot be persisted */ }
-    return { decision: 'repair-requested', reason: `${judged.judgement.move} → dispatch · run ${runId} · ${detail}` };
+    return { decision: 'repair-requested', reason: `${judged.judgement.move} → dispatch · move ${moveId} · run ${runId} · ${detail}` };
   }
-  return { decision: 'repair-requested', reason: `${judged.judgement.move} → dispatch · run ${runId} · ${from} → ${to.provider}/${to.model}` };
+  return { decision: 'repair-requested', reason: `${judged.judgement.move} → dispatch · move ${moveId} · run ${runId} · ${from} → ${to.provider}/${to.model}` };
 }