elanous 0.2.34 → 0.2.36

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

@@ -10,16 +10,21 @@ 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 { 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 {
@@ -29,7 +34,9 @@ export interface RepairCycleInput {
   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 +103,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 +135,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 +182,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 +270,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 +287,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 +296,16 @@ 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');
   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 });
+    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 === '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 +348,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 +401,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 +428,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}` };
 }

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

@@ -1,4 +1,5 @@
 /** Existing TA retry judgement, routed through the declared recover → dispatch graph edge. */
+import { randomBytes } from 'node:crypto';
 import { judgeNextMove, type TaskJudgement } from './judge.js';
 import { readJourneyEdge, type JourneyRoute } from '../self-dev/graph-journey-route.js';
 
@@ -11,10 +12,37 @@ export interface RepairNextMoveInput {
   priorAlternativeAttempts: number;
 }
 
-export type RepairNextMove = { kind: 'dispatch'; judgement: TaskJudgement; route: JourneyRoute; source: `pr:${number}` }
+/** HARNESS-FULL-GRAPH-NEXTMOVE — 수 한 건의 식별자. 결정 순간 «한 번» 만들고, 그 값을 결정·간선·발사에 그대로 내려보낸다(다시 계산 금지). */
+export function mintMoveId(): string {
+  return `mv-${randomBytes(6).toString('hex')}`;
+}
+
+/**
+ * NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 소비 쪽(결과 파일 · `ta.repair.completed`)이 카드에 적힌 수 id 와 받은 값을 짝짓는다.
+ * - `paired`   : 둘 다 있고 같다 → 그 값을 카드 결과 줄에 싣는다.
+ * - `legacy`   : 둘 다 없다(#30226 전 원장 줄 · 옛 worker) → 조용히 지나간다.
+ * - `unpaired` : 한쪽만 있거나 다르다 → 소비는 그대로 하고(fail-soft) 관측 줄만 남긴다.
+ */
+export type MoveIdPairing = { kind: 'paired'; moveId: string } | { kind: 'legacy' }
+  | { kind: 'unpaired'; expected: string | null; observed: string | null };
+
+export function pairMoveId(expected: unknown, observed: unknown): MoveIdPairing {
+  const want = typeof expected === 'string' && expected ? expected : null;
+  const got = typeof observed === 'string' && observed ? observed : null;
+  if (want === null && got === null) return { kind: 'legacy' };
+  if (want !== null && want === got) return { kind: 'paired', moveId: want };
+  return { kind: 'unpaired', expected: want, observed: got };
+}
+
+export interface RepairNextMoveDeps {
+  /** 시험 seam — 기본 `mintMoveId`. dispatch 결정일 때만 한 번 부른다. */
+  mintMoveId?: () => string;
+}
+
+export type RepairNextMove = { kind: 'dispatch'; judgement: TaskJudgement; route: JourneyRoute; source: `pr:${number}`; moveId: string }
   | { kind: 'stop'; judgement: TaskJudgement; route: JourneyRoute; reason: string };
 
-export function repairNextMove(input: RepairNextMoveInput): RepairNextMove {
+export function repairNextMove(input: RepairNextMoveInput, deps: RepairNextMoveDeps = {}): RepairNextMove {
   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 });
@@ -27,5 +55,5 @@ export function repairNextMove(input: RepairNextMoveInput): RepairNextMove {
   if (judged.move !== 'narrow-relaunch' && judged.move !== 'salvage-relaunch' && judged.move !== 'alternative') {
     return { kind: 'stop', judgement: judged, route, reason: `next move ${judged.move} is not a repair launch` };
   }
-  return { kind: 'dispatch', judgement: judged, route, source: `pr:${input.pr}` };
+  return { kind: 'dispatch', judgement: judged, route, source: `pr:${input.pr}`, moveId: (deps.mintMoveId ?? mintMoveId)() };
 }

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

@@ -0,0 +1,29 @@
+import type { TaskCard } from './task-hand.js';
+
+/** Count confirmed repair-result transitions, not repeated rejudge decisions or current card status. */
+export function measureRepairOutcomes(cards: readonly Pick<TaskCard, 'id' | 'history'>[], window: { since: number; until: number }) {
+  const affected = new Set<string>();
+  const latest = new Map<string, { effect: string | undefined; at: number; card: string }>();
+  const counts = { applied: 0, failed: 0, unconfirmed: 0, results: 0, missingRunId: 0, unknownEffect: 0 };
+  for (const card of cards) {
+    for (const entry of card.history) {
+      if (entry.event !== 'repair-result') continue;
+      const at = Date.parse(entry.at);
+      if (!Number.isFinite(at) || at < window.since || at >= window.until) continue;
+      // A repeated collector must not count a worker result twice.
+      if (!entry.runId) { counts.missingRunId++; continue; }
+      const key = `${card.id}\0${entry.runId}`;
+      if (at >= (latest.get(key)?.at ?? -Infinity)) latest.set(key, { effect: entry.effect, at, card: card.id });
+    }
+  }
+  for (const result of latest.values()) {
+    if (result.effect === 'applied' || result.effect === 'failed' || result.effect === 'unconfirmed') {
+      counts[result.effect]++;
+    } else {
+      counts.unknownEffect++;
+    }
+    counts.results++;
+    affected.add(result.card);
+  }
+  return { ...counts, cards: affected.size };
+}

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

@@ -5,6 +5,7 @@ import { dirname } from 'node:path';
 import type { RepairCommitResult } from './repair-branch-cas.js';
 import type { TaskChildLlm } from './task-hand.js';
 import { publishInsideEvent } from '../nexus/api/inside-events.js';
+import { taskParentRoleEnv } from './task-parent-role-llm.js';
 
 const SHA40 = /^[0-9a-f]{40}$/i;
 const SHA256 = /^[0-9a-f]{64}$/i;
@@ -14,10 +15,13 @@ export interface RepairWorkerRequest {
   card: string; pr: number; head: string; repo: string; resultPath: string;
   entry: string; configDir: string; runId: string; seat?: string;
   model: TaskChildLlm; goal: string;
+  parentRoleLlm?: string[];
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — 이 발사를 고른 next-move 결정의 수 id(관측 조인 · 없으면 옛 발사). */
+  moveId?: string;
 }
 
 export interface RepairWorkerResult {
-  pr: number; head: string; runId: string; ok: boolean; reason?: string;
+  pr: number; head: string; runId: string; ok: boolean; reason?: string; moveId?: string;
   job?: string; artifactDir?: string; result?: RepairCommitResult;
 }
 
@@ -31,6 +35,11 @@ export function repairHarnessArgs(request: RepairWorkerRequest): string[] {
     ...(request.model.effort ? ['--child-llm-effort', request.model.effort] : []), '--', request.goal];
 }
 
+/** The harness-say parent reads role pins from env; its CLI has no --role-llm flag. */
+export function repairWorkerEnv(request: RepairWorkerRequest): Record<string, string> {
+  return { ELANOUS_RUN_ID: request.runId, ...taskParentRoleEnv(request.parentRoleLlm ?? []) };
+}
+
 export function parseRepairMarker(output: string, pr: number, head: string, runId: string): Pick<RepairWorkerResult, 'job' | 'artifactDir' | 'result'> | null {
   const line = output.split(/\r?\n/).reverse().find((entry: string) => entry.startsWith(MARKER));
   if (!line) return null;
@@ -46,11 +55,12 @@ export function parseRepairMarker(output: string, pr: number, head: string, runI
 }
 
 export async function runRepairWorker(request: RepairWorkerRequest): Promise<RepairWorkerResult> {
-  const result: RepairWorkerResult = { pr: request.pr, head: request.head, runId: request.runId, ok: false };
+  const result: RepairWorkerResult = { pr: request.pr, head: request.head, runId: request.runId, ok: false,
+    ...(request.moveId ? { moveId: request.moveId } : {}) };
   try {
     const args = repairHarnessArgs(request);
     const child = spawn(process.execPath, args, {
-      cwd: request.repo, env: { ...process.env, ELANOUS_RUN_ID: request.runId }, stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: request.repo, env: { ...process.env, ...repairWorkerEnv(request) }, stdio: ['ignore', 'pipe', 'pipe'],
     });
     let output = '';
     const append = (data: Buffer) => { output = (output + data.toString('utf8')).slice(-512_000); };
@@ -74,7 +84,7 @@ export async function runRepairWorker(request: RepairWorkerRequest): Promise<Rep
   // The result file, rather than this best-effort notification, is the durable source.
   try {
     publishInsideEvent({ kind: 'ta.repair.completed', schema: 1, card: request.card,
-      pr: request.pr, head: request.head, runId: request.runId,
+      pr: request.pr, head: request.head, runId: request.runId, ...(request.moveId ? { moveId: request.moveId } : {}),
       resultPath: request.resultPath, completedAt: new Date().toISOString() });
   } catch { /* a missing daemon cannot change the worker result */ }
   return result;

package/src/task-agent/shadow.ts

@@ -17,6 +17,7 @@ import { extname, join, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
 import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
+import { mintMoveId } from './repair-next-move.js';
 import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import { executeNextAction, type ActionDeps, type DeliveryKind, type NextAction } from './actions.js';
@@ -57,6 +58,8 @@ export interface TaskAgentShadowMove {
   liveMove?: LiveMoveResult;
   /** 원격 카드 결선이 미결일 때 런 원장 대기열 보존 결과. */
   cardBinding?: 'pending' | 'queue-failed';
+  /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 실제로 발사를 시도한 일반 재발사의 수 id(그림자 수엔 없다). */
+  moveId?: string;
 }
 
 export interface TaskAgentShadowDeps {
@@ -82,6 +85,8 @@ export interface TaskAgentShadowDeps {
   env?: NodeJS.ProcessEnv;
   /** Remote pending-move ledger seam; defaults to the run ledger. */
   queueMove?: typeof appendRunLedgerEntry;
+  /** 시험 seam — 일반 재발사 결정의 수 id 발급기(기본 `mintMoveId` · #30226 과 같은 것). live 재발사로 갈 때 결정 순간 한 번만 불린다. */
+  mintMoveId?: () => string;
 }
 
 const execFileAsync = promisify(execFile);
@@ -104,6 +109,32 @@ export async function defaultPrFiles(pr: number, prUrl: string | undefined,
 
 export const REMOTE_CARD_MOVE_PENDING = 'task-agent-card-move-pending';
 
+/** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 일반 재발사가 발사 명령을 «성공»으로 받은 뒤 그 카드 history 에 남기는 줄의 이름. */
+export const RELAUNCH_LAUNCHED_EVENT = 'relaunch-launched';
+
+/**
+ * 일반 재발사 한 건을 그 런의 카드 history 에 한 줄로 남긴다 — 결정·간선·발사 argv 와 같은 수 id.
+ * 카드·원장을 모르면 쓰지 않고 관측만 남긴다(fail-soft · 발사는 이미 됐다).
+ */
+function recordRelaunchHistory(card: TaskCard | undefined, ledger: string | undefined,
+  input: { runId: string | null; move: string; moveId: string | undefined; deps: TaskAgentShadowDeps }): void {
+  const log = input.deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data));
+  if (!input.moveId) return;
+  if (!card || !ledger) {
+    try { log('task-agent', 'relaunch-history-skipped', { runId: input.runId, move: input.move, moveId: input.moveId,
+      reason: !card ? 'card unknown' : 'card ledger unknown' }); } catch { /* fail-soft */ }
+    return;
+  }
+  try {
+    updateTaskCard(ledger, card.id, (current) => current ? { ...current, history: [...(current.history ?? []), {
+      at: new Date().toISOString(), event: RELAUNCH_LAUNCHED_EVENT, ...(input.runId ? { runId: input.runId } : {}),
+      effect: input.move, moveId: input.moveId }] } : undefined);
+  } catch (error) {
+    try { log('task-agent', 'relaunch-history-failed', { card: card.id, runId: input.runId, moveId: input.moveId,
+      reason: (error instanceof Error ? error.message : String(error)).slice(-300) }); } catch { /* fail-soft */ }
+  }
+}
+
 /** 카드 조회 상태 파일 — 조회 경로 전부가 같은 파일을 본다. */
 function cardStatePath(deps: TaskAgentShadowDeps): string {
   return deps.statePath ?? deps.live?.statePath ?? taskAgentStatePath();
@@ -317,6 +348,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   const retryLaunches = { count: 0 };
   let executorResult: string | null = null;
   let wouldDo: string | null = null;
+  let generalMoveId: string | undefined;
   if (judgement.executorKind) {
     const action: NextAction = {
       kind: judgement.executorKind,
@@ -334,16 +366,27 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       { move: judgement.move, source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, runId: input.runId }) : null;
     const liveRetry = retryMove && route?.source === 'graph' && route.to === 'dispatch'
       && deps.command !== undefined && deps.loadGate !== undefined && liveMoves.has(judgement.move as TaskAgentLiveMove);
-    executorResult = await executeNextAction(action, {
+    // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — live 재발사로 가는 결정 순간 수 id 를 «한 번» 만든다(이미 실린 값이 있으면 그것).
+    //   아래 발사 argv · 결정 노드 출구 · graph-edge-taken · 카드 history 가 이 값만 쓴다(다시 만들지 않는다).
+    if (liveRetry) generalMoveId = action.moveId ?? (deps.mintMoveId ?? mintMoveId)();
+    executorResult = await executeNextAction(generalMoveId ? { ...action, moveId: generalMoveId } : action, {
       mode: delivery ? (deps.mode ?? 'shadow') : liveRetry ? 'live' : 'shadow',
       command: deps.command ?? (async () => { throw new Error('task-agent shadow path must not run commands'); }),
-      observe: (_event, data) => { wouldDo = data.reason; },
+      observe: (event, data) => {
+        wouldDo = data.reason;
+        // Keep new denominator rows out of the legacy task-agent/action aggregate.
+        if (event !== 'task-agent.entrance-denominator') return;
+        try { (deps.log ?? ((category, name, row) => debug.log(category, name, row)))('task-agent', 'entrance-denominator', { ...data }); }
+        catch { /* Observation must not alter the selected move. */ }
+      },
       ...(liveRetry ? { liveMoves, retryLaunches, loadGate: deps.loadGate } : {}),
     });
     if (liveRetry && executorResult === 'done' && route) {
       passJourneyNode('next-move', { provenance: 'task-agent-terminal', outcome: judgement.move,
-        runId: input.runId ?? undefined, data: { source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, pr: judgeInput.pr ?? null } });
-      recordJourneyEdge(route, 'dispatch');
+        runId: input.runId ?? undefined, data: { source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, pr: judgeInput.pr ?? null,
+          ...(generalMoveId ? { moveId: generalMoveId } : {}) } });
+      recordJourneyEdge(route, 'dispatch', undefined, generalMoveId ? { moveId: generalMoveId } : {});
+      recordRelaunchHistory(card, cardLedgerPath(deps), { runId: input.runId, move: judgement.move, moveId: generalMoveId, deps });
     }
   }
   const move: TaskAgentShadowMove = {
@@ -356,6 +399,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     executorResult,
     wouldDo,
     pr: delivery ? null : typeof judgeInput.pr === 'number' ? judgeInput.pr : null,
+    ...(generalMoveId ? { moveId: generalMoveId } : {}),
   };
   if (delivery && deps.mode !== 'live') {
     move.wouldDo = `${move.wouldDo ?? 'would wait'} → ${join(delivery.projectTarget, 'elanous-out', card!.id)} (${delivery.files.join(', ')})`;

package/src/task-agent/task-card-prefix.ts

@@ -0,0 +1,2 @@
+/** 과제 카드 id 접두 — `task show <id>` 가 이 접두로 TOX 태스크와 갈린다(가벼운 읽기 경로가 task-hand 를 싣지 않고 쓴다). */
+export const TASK_CARD_PREFIX = 'ta-';