elanous 0.2.36 → 0.2.38

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

@@ -102,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. */
@@ -346,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;
@@ -367,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]); };
 
@@ -495,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
@@ -543,6 +552,25 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
       : 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
@@ -552,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);
@@ -560,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
@@ -938,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;
@@ -949,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

@@ -1,5 +1,6 @@
 /** HQ same-PR repair launch and result collection; the reviewed head is the sole source of truth. */
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
 import { debug } from '../debug/log.js';
@@ -11,13 +12,16 @@ 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 { pairMoveId, repairNextMove } from './repair-next-move.js';
-import { parseRepairWorkerResult } from './repair-worker.js';
+import type { SupervisorGoalDeficit } from '../self-implement/goal-supervisor-fill.js';
+import { loadRunLedger, type RunLedgerEntry } from '../self-implement/run-ledger.js';
+import { parseRepairWorkerResult, repairFailureSignature } 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, '_');
+const reviewSignature = (mustFix: readonly string[]) => createHash('sha256').update(JSON.stringify(mustFix)).digest('hex');
 
 export interface RepairLaunchRequest {
   card: string; pr: number; head: string; repo: string; resultPath: string;
@@ -30,6 +34,9 @@ export interface RepairLaunchRequest {
 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;
@@ -103,9 +110,9 @@ 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');
-  // 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' };
+  // Pin the full model route; a bare glm-5.3 can be ambiguous in the Pod review path.
+  // A failed full GLM repair must never be retried with the smaller flash model.
+  const glm: TaskChildLlm = { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3' };
   const sol: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-sol' };
   const grok: TaskChildLlm = { provider: 'grok', model: 'grok-4.6' };
   const tier = card.tier ?? '중';
@@ -270,6 +277,8 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       }
     }
     const status = applied?.ok ? 'applied' : applied?.unconfirmed ? 'unconfirmed' : 'failed';
+    const failureSignature = status === 'failed' && !result.ok
+      ? result.failureSignature ?? repairFailureSignature(result.reason ?? '') : null;
     // 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,
@@ -277,13 +286,16 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     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 });
+      model: latest.toModel, resultPath: latest.resultPath, artifactDir: result.artifactDir ?? null, status, detail,
+      ...(result.gateFailureTests ? { gateFailureTests: result.gateFailureTests } : {}) });
     } 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)))
         ? { ...current, repairs: current.repairs.map((entry) => entry.runId === latest.runId
-          ? { ...entry, status, detail, ...(result?.result && status === 'unconfirmed' ? { commit: result.result.commit,
+          ? { ...entry, status, detail, ...(failureSignature ? { failureSignature } : {}),
+            ...(failureSignature?.startsWith('gate:') && result.gateFailureTests ? { gateFailureTests: result.gateFailureTests } : {}),
+            ...(result?.result && status === 'unconfirmed' ? { commit: result.result.commit,
             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,
@@ -297,10 +309,46 @@ 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,
+    ...(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 (failedAttempts.length >= 2) {
       const detail = `수리 수렴 실패: PR #${pr} head ${head.slice(0, 12)} · 실패 ${failedAttempts.length}회 · ${judged.reason}`;
@@ -387,10 +435,61 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     return { decision: 'would-repair', reason };
   }
   const next = attempts.length + 1;
-  const runId = mintRunId();
   // 결정 순간 만든 수 id — 아래 발사·카드·관측이 «이 값»만 쓴다(다시 만들지 않는다).
   const moveId = judged.moveId;
   const { from, to } = alternateRepairModel(card, availability);
+  const nextModel = `${to.provider}/${to.model}`;
+  const repeatSignature = latest?.status === 'failed' && latest.head.toLowerCase() === head.toLowerCase()
+    && latest.reviewSignature === reviewSignature(input.mustFix) && latest.failureSignature
+    && (latest.failureSignature.startsWith('gate:sha256:')
+      || latest.failureSignature.startsWith('provider:ambiguous-primary:') && latest.toModel === nextModel)
+    ? latest.failureSignature : null;
+  if (repeatSignature) {
+    const prior = latest!;
+    const tests = prior.gateFailureTests?.slice(0, 4).join(' | ');
+    const reason = `same PR/head/review deterministic repair failure ${repeatSignature}; owner repair required${tests ? ` · ${tests}` : ''}`;
+    let recorded = false;
+    updateTaskCard(statePath, card.id, (current) => {
+      if (!current || current.status !== 'launched' || !current.repairs?.some((entry) =>
+        entry.runId === prior.runId && entry.status === 'failed' && entry.failureSignature === repeatSignature
+        && entry.reviewSignature === prior.reviewSignature)
+        || current.history?.some((entry) => entry.event === 'repair-signature-repeat-stopped' && entry.pr === pr
+          && entry.head?.toLowerCase() === head.toLowerCase() && entry.runId === prior.runId)) return undefined;
+      recorded = true;
+      return { ...current, status: 'failed', history: [...(current.history ?? []),
+        { at: now.toISOString(), event: 'repair-signature-repeat-stopped', pr, head, runId: prior.runId, detail: reason }] };
+    });
+    if (recorded) try { debug.log('task-agent', 'repair-signature-repeat-stopped', { card: card.id, pr, head,
+      signature: repeatSignature, priorRunId: prior.runId, skippedRelaunch: true }); } catch { /* fail-soft */ }
+    let notifyClaimed = false;
+    updateTaskCard(statePath, card.id, (current) => {
+      const history = current?.history ?? [];
+      const lastAlert = history.filter((entry) => entry.runId === prior.runId && entry.event.startsWith('repair-repeat-owner-')).at(-1);
+      const staleClaim = lastAlert?.event === 'repair-repeat-owner-claimed'
+        && now.getTime() - Date.parse(lastAlert.at) >= ALERT_CLAIM_STALE_MS;
+      if (!current || !history.some((entry) => entry.event === 'repair-signature-repeat-stopped'
+        && entry.pr === pr && entry.head?.toLowerCase() === head.toLowerCase() && entry.runId === prior.runId)
+        || lastAlert && lastAlert.event !== 'repair-repeat-owner-failed' && !staleClaim) return undefined;
+      notifyClaimed = true;
+      return { ...current, history: [...history,
+        { at: now.toISOString(), event: 'repair-repeat-owner-claimed', pr, head, runId: prior.runId, detail: reason }] };
+    });
+    if (notifyClaimed) {
+      let event = 'repair-repeat-owner-sent';
+      let detail = reason;
+      try {
+        (input.notify ?? defaultNotify)(owner.seat, `${reason} · card ${card.id} · owner ${owner.seat} via ${owner.source}`);
+      } catch (error) {
+        event = 'repair-repeat-owner-failed';
+        detail = `${reason} · ${String(error).slice(0, 200)}`;
+      }
+      updateTaskCard(statePath, card.id, (current) => current?.history?.some((entry) =>
+        entry.event === 'repair-repeat-owner-claimed' && entry.runId === prior.runId)
+        ? { ...current, history: [...current.history, { at: now.toISOString(), event, pr, head, runId: prior.runId, detail }] } : undefined);
+    }
+    return { decision: 'repair-stopped', reason };
+  }
+  const runId = mintRunId();
   const resultPath = repairResultPath(statePath, card.id, pr, head, next, runId);
   const goalFile = resultPath.replace(/\.json$/, '.goal.txt');
   const goal = `기존 PR #${pr}의 리뷰 때 head ${head}를 같은 가지에서 수리한다. 새 PR을 열지 말고 아래 must-fix 원문만 고쳐 commit-only 결과를 반환한다.\n\n${input.mustFix.map((item, i) => `${i + 1}. ${item}`).join('\n')}`;
@@ -401,7 +500,8 @@ 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, moveId, 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}`,
+      reviewSignature: reviewSignature(input.mustFix), status: 'requested' }],
       history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-launched', pr, head, runId,
         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}` }] };
   });

package/src/task-agent/repair-next-move.ts

@@ -1,5 +1,6 @@
 /** Existing TA retry judgement, routed through the declared recover → dispatch graph edge. */
 import { randomBytes } from 'node:crypto';
+import type { SupervisorGoalDeficit, SupervisorGoalFillResult } from '../self-implement/goal-supervisor-fill.js';
 import { judgeNextMove, type TaskJudgement } from './judge.js';
 import { readJourneyEdge, type JourneyRoute } from '../self-dev/graph-journey-route.js';
 
@@ -10,6 +11,8 @@ export interface RepairNextMoveInput {
   mustFix: readonly string[];
   priorNarrowAttempts: number;
   priorAlternativeAttempts: number;
+  supervisorDeficit?: SupervisorGoalDeficit;
+  supervisorResult?: SupervisorGoalFillResult;
 }
 
 /** HARNESS-FULL-GRAPH-NEXTMOVE — 수 한 건의 식별자. 결정 순간 «한 번» 만들고, 그 값을 결정·간선·발사에 그대로 내려보낸다(다시 계산 금지). */
@@ -40,9 +43,16 @@ export interface RepairNextMoveDeps {
 }
 
 export type RepairNextMove = { kind: 'dispatch'; judgement: TaskJudgement; route: JourneyRoute; source: `pr:${number}`; moveId: string }
-  | { kind: 'stop'; judgement: TaskJudgement; route: JourneyRoute; reason: string };
+  | { kind: 'stop'; judgement: TaskJudgement; route: JourneyRoute; reason: string }
+  | { kind: 'grounding'; action: 'remeasure' | 'connect-goal'; supervisorDeficit: SupervisorGoalDeficit };
 
-export function repairNextMove(input: RepairNextMoveInput, deps: RepairNextMoveDeps = {}): RepairNextMove {
+export function repairNextMove(input: RepairNextMoveInput | { supervisorDeficit: SupervisorGoalDeficit; supervisorResult?: 'unverifiable' | 'rejected' }, deps: RepairNextMoveDeps = {}): RepairNextMove {
+  const deficit = input.supervisorDeficit;
+  if (input.supervisorResult !== 'filled' && input.supervisorResult !== 'already-filled'
+    && (deficit?.kind === 'unmeasured' || deficit?.kind === 'unwired')) {
+    return { kind: 'grounding', action: deficit.kind === 'unmeasured' ? 'remeasure' : 'connect-goal', supervisorDeficit: deficit };
+  }
+  if (!('pr' in input)) throw new Error('grounding evidence is not an actionable repair move');
   const judged = judgeNextMove({ stopReason: 'needs-human', pr: input.pr, prState: 'OPEN', review: 'fail', mustFix: input.mustFix,
     failures: { 'narrow-relaunch': input.priorNarrowAttempts, alternative: input.priorAlternativeAttempts } });
   const route = readJourneyEdge('next-move', judged.move, { move: judged.move, source: `pr:${input.pr}`, head: input.head, branch: input.branch });

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

@@ -22,9 +22,32 @@ export interface RepairWorkerRequest {
 
 export interface RepairWorkerResult {
   pr: number; head: string; runId: string; ok: boolean; reason?: string; moveId?: string;
+  /** A classified, stable failure only. Generic gate-failed is deliberately unsigned. */
+  failureSignature?: string;
+  /** Exact introduced test identities from the same signed gate receipt. */
+  gateFailureTests?: string[];
   job?: string; artifactDir?: string; result?: RepairCommitResult;
 }
 
+export function repairFailureSignature(output: string): string | null {
+  const gate = output.match(/^GATE_FAILURE_SIGNATURE=sha256:([a-f0-9]{64})\s*$/m);
+  if (gate) return `gate:sha256:${gate[1]}`;
+  const model = output.match(/review fallback: ambiguous or unsupported primary model ["“]([^"”\n]+)["”]/i);
+  const name = model?.[1]?.trim().toLowerCase();
+  return name && /^[a-z0-9._/-]{1,120}$/.test(name) ? `provider:ambiguous-primary:${name}` : null;
+}
+
+export function repairGateFailureTests(output: string): string[] | null {
+  const line = /^GATE_FAILURE_TESTS=(\[[^\r\n]*\])\s*$/m.exec(output)?.[1];
+  if (!line) return null;
+  try {
+    const tests: unknown = JSON.parse(line);
+    return Array.isArray(tests) && tests.length > 0 && tests.length <= 32
+      && tests.every((test) => typeof test === 'string' && test.length > 0 && test.length <= 512)
+      ? tests as string[] : null;
+  } catch { return null; }
+}
+
 export function repairHarnessArgs(request: RepairWorkerRequest): string[] {
   if (!Number.isSafeInteger(request.pr) || request.pr < 1 || !SHA40.test(request.head)
     || !request.goal.trim() || !request.runId) throw new Error('repair worker request invalid');
@@ -71,7 +94,15 @@ export async function runRepairWorker(request: RepairWorkerRequest): Promise<Rep
       child.once('close', resolve);
     });
     const marker = parseRepairMarker(output, request.pr, request.head, request.runId);
-    if (code !== 0) result.reason = `harness exited ${code}: ${output.slice(-600)}`;
+    if (code !== 0) {
+      result.reason = `harness exited ${code}: ${output.slice(-600)}`;
+      const failureSignature = repairFailureSignature(output);
+      if (failureSignature) {
+        result.failureSignature = failureSignature;
+        const tests = failureSignature.startsWith('gate:') ? repairGateFailureTests(output) : null;
+        if (tests) result.gateFailureTests = tests;
+      }
+    }
     else if (!marker) result.reason = `repair artifact marker missing or invalid: ${output.slice(-600)}`;
     else Object.assign(result, { ok: true, ...marker });
   } catch (error) {
@@ -96,6 +127,11 @@ export function parseRepairWorkerResult(text: string, pr: number, head: string,
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const v = value as RepairWorkerResult;
   if (v.pr !== pr || typeof v.head !== 'string' || v.head.toLowerCase() !== head.toLowerCase() || v.runId !== runId || typeof v.ok !== 'boolean') return null;
+  if (v.failureSignature !== undefined && (typeof v.failureSignature !== 'string'
+    || !/^(?:gate:sha256:[a-f0-9]{64}|provider:ambiguous-primary:[a-z0-9._/-]{1,120})$/.test(v.failureSignature))) delete v.failureSignature;
+  if (v.gateFailureTests !== undefined && (!v.failureSignature?.startsWith('gate:')
+    || !Array.isArray(v.gateFailureTests) || v.gateFailureTests.length < 1 || v.gateFailureTests.length > 32
+    || !v.gateFailureTests.every((test) => typeof test === 'string' && test.length > 0 && test.length <= 512))) delete v.gateFailureTests;
   if (v.ok && (typeof v.artifactDir !== 'string' || !v.artifactDir.startsWith('/') || typeof v.job !== 'string' || !v.job
     || !v.result || v.result.pr !== pr || typeof v.result.baseHead !== 'string'
     || v.result.baseHead.toLowerCase() !== head.toLowerCase() || v.result.runId !== runId || !SHA40.test(v.result.commit)

package/src/task-agent/review-prior-fix.ts

@@ -49,7 +49,14 @@ export function priorReviewRequest(requests: readonly ReviewRequest[] | undefine
  * 결과 파일에서 must-fix «문면»을 읽는다 — `self review --json` 의 결과 줄(뒤에서부터 첫 결과 모양)만.
  * 결과 모양 판정은 `parseReviewResultOutput` 과 같다(PR 번호 ⊕ (verdict ⊕ mustFix 배열 | error 문자열)).
  */
-export function readPriorMustFix(path: string | undefined, pr: number, read: (path: string) => string = (p) => readFileSync(p, 'utf8')): PriorMustFix {
+export function readPriorMustFix(
+  path: string | undefined,
+  pr: number,
+  expectedHeadOrRead?: string | ((path: string) => string),
+  readFile: (path: string) => string = (p) => readFileSync(p, 'utf8'),
+): PriorMustFix {
+  const expectedHead = typeof expectedHeadOrRead === 'string' ? expectedHeadOrRead : undefined;
+  const read = typeof expectedHeadOrRead === 'function' ? expectedHeadOrRead : readFile;
   if (!path) return { status: 'not-recovered', reason: 'no result path' };
   let text: string;
   try { text = read(path); } catch (error) {
@@ -68,6 +75,9 @@ export function readPriorMustFix(path: string | undefined, pr: number, read: (pa
     if (!isResult) continue;
     const prRaw = typeof v.pr === 'number' ? v.pr : typeof v.pr === 'string' ? Number(String(v.pr).replace(/^#/, '')) : NaN;
     if (prRaw !== pr) return { status: 'not-recovered', reason: `result PR ${Number.isFinite(prRaw) ? prRaw : 'unknown'} does not match #${pr}` };
+    if (expectedHead && (typeof v.headCommit !== 'string' || !SHA40.test(expectedHead) || v.headCommit.toLowerCase() !== expectedHead.toLowerCase())) {
+      return { status: 'not-recovered', reason: 'result head does not match prior review head' };
+    }
     if (typeof v.error === 'string') return { status: 'not-recovered', reason: `prior review error: ${v.error.slice(0, 200)}` };
     if (v.reviewed === false) return { status: 'not-recovered', reason: 'prior review did not run (reviewed:false)' };
     if (!Array.isArray(v.mustFix) || !v.mustFix.every((fix) => typeof fix === 'string')) return { status: 'not-recovered', reason: 'must-fix list unreadable' };
@@ -109,7 +119,7 @@ export function buildPriorFixContext(
   if (!prior) return null;
   let diff: PriorDiff | null;
   try { diff = (opts.priorDiff ?? defaultPriorDiff)(opts.cwd, prior.head, head); } catch { diff = null; }
-  return { fromHead: prior.head, toHead: head, diff, mustFix: readPriorMustFix(prior.resultPath, pr, opts.readFile) };
+  return { fromHead: prior.head, toHead: head, diff, mustFix: readPriorMustFix(prior.resultPath, pr, prior.head, opts.readFile) };
 }
 
 /** «직전 반영분» 블록 — 종전 런 줄 다음에 붙는다. */