elanous 0.2.32 → 0.2.34

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

@@ -29,10 +29,13 @@
  * - 관측: `task-agent` · `rejudge-on-head {card, pr, fromHead, toHead, step, decision, reason}` — 수가 난 판단은 카드 history 에도
  *   한 줄(`event:'rejudge-on-head'` · 같은 머리·같은 단계·같은 판단은 한 번).
  */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { planPrLandRecovery, type PrLandRecoveryPlan } from '../cli/pr-land-recovery.js';
+import { lastJsonObject, runGraph } from '../graph-runner/runner.js';
 import { debug } from '../debug/log.js';
 import { prodInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig } from '../user-config.js';
@@ -44,7 +47,7 @@ import { recordLiveMoveHistory } from './live-move-history.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';
-import { defaultLandPrHead, defaultPrHead, defaultReviewRepoCandidates, executeLiveLand, executeLiveReview, landRetryPending, type LiveMoveDeps, type LiveMoveResult, type PrHeadView, type ReviewRepoCandidate, type TaskAgentLiveMove } from './live-moves.js';
+import { configuredMsb1Worker, defaultLandPrHead, defaultPrHead, defaultReviewRepoCandidates, executeLiveLand, executeLiveReview, landRetryPending, remoteTaWorkerCommand, type LiveMoveDeps, type LiveMoveResult, type PrHeadView, type ReviewRepoCandidate, type TaskAgentLiveMove } from './live-moves.js';
 import { capturedLandReview, captureReviewResults, parseReviewResultOutput, pendingReviewResults, reviewResultPath, type ParsedReviewResult } from './review-result-capture.js';
 import { boundPrTerminal, cardPrNumber, LIVE_MOVE_RESULT_EVENT, readTaskCard, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 import { verifiedTrainLanding, type TrainLanding } from './train-landing.js';
@@ -98,6 +101,10 @@ 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;
+  /** 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. */
+  landBudget?: { max: number; requested: number };
   /** TA-REJUDGE-REBASE-LOOP — origin/main 을 PR 가지에 3-way merge 하고 일반 push. 시험은 주입한다. */
   catchUpMain?: (request: CatchUpRequest) => Promise<CatchUpResult>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
@@ -265,12 +272,28 @@ export function regateRunArgs(entry: string, configDir: string, request: RegateR
   return [entry, '--config-dir', configDir, 'tasks', 'regate-run', '--card', request.card, '--pr', String(request.pr), '--head', request.head, '--repo', request.repoRoot, '--out', request.resultPath];
 }
 
-export async function defaultRequestRegate(request: RegateRequest, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string } = {}): Promise<void> {
+export async function defaultRequestRegate(request: RegateRequest, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; remote?: import('./parent-host.js').ParentHostConfig | null } = {}): Promise<void> {
   const { spawnDetachedConfirmed, ELANOUS_CLI_ENTRY } = await import('../cli/tasks-cli.js');
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const configDir = opts.configDir ?? getElanousConfigDirOverride() ?? effectiveInstanceRoot();
-  await spawnDetachedConfirmed(opts.spawn ?? (spawn as unknown as DetachedSpawn), process.execPath, regateRunArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, request), undefined, request.repoRoot);
+  const base = opts.spawn ?? (spawn as unknown as DetachedSpawn);
+  const remote = opts.remote === undefined ? (opts.spawn ? null : configuredMsb1Worker()) : opts.remote;
+  if (!remote) {
+    await spawnDetachedConfirmed(base, process.execPath, regateRunArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, request), undefined, request.repoRoot);
+    return;
+  }
+  // The remote worker writes its own result, then SSH carries only that JSON into the HQ result path.
+  const remoteResult = `/tmp/elanous-ta-regate-${randomUUID()}.json`;
+  const script = `${remoteTaWorkerCommand(remote, ['tasks', 'regate-run', '--card', request.card, '--pr', String(request.pr),
+    '--head', request.head, '--repo', remote.cwd, '--out', remoteResult])} >/dev/null; rc=$?; cat '${remoteResult}'; rm -f '${remoteResult}'; exit $rc`;
+  mkdirSync(dirname(request.resultPath), { recursive: true });
+  const fd = openSync(request.resultPath, 'w');
+  const toFile: DetachedSpawn = (command, args, options) =>
+    (base as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, args, { ...options, stdio: ['ignore', fd, 'ignore'] });
+  try {
+    await spawnDetachedConfirmed(toFile, 'ssh', ['-T', '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5', remote.host, script]);
+  } finally { closeSync(fd); }
 }
 
 /** 재게이트 결과 파일 — `tasks regate-run` 이 쓴다. */
@@ -513,6 +536,19 @@ 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> => {
+    const budget = deps.reviewBudget;
+    if (budget && budget.requested >= budget.max) {
+      step('review', 'tick-cap', `review request cap ${budget.max} reached — next tick`, false);
+      return;
+    }
+    // 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 } : {}) });
+    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);
+  };
 
   // Adoption is a first judgement for the current head, even when the implementation run
   // already asked for a review. A captured failure needs repair; an accepted result must
@@ -526,10 +562,7 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     } else if (!deps.liveMoves.has('review')) {
       step('review', 'would-review', 'adopted PR first judgement · review not enabled in HQ taskAgent.liveMoves — shadow', false);
     } else {
-      const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
-      const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'adopted-pr-first-judgement', cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
-      recordMove(statePath, card.id, card.runId, 'review', result, pr, before, now, deps.log);
-      step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
+      await requestReview(card, 'adopted-pr-first-judgement');
     }
     return outcomes;
   }
@@ -618,12 +651,7 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
 
   if (!reviews.length) {
     if (!deps.liveMoves.has('review')) step('review', 'would-review', 'remote run terminal proven · review not enabled in HQ taskAgent.liveMoves — shadow', false);
-    else {
-      const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
-      const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'remote-run-terminal', cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
-      recordMove(statePath, card.id, card.runId, 'review', result, pr, before, now, deps.log);
-      step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
-    }
+    else await requestReview(card, 'remote-run-terminal');
     return outcomes;
   }
 
@@ -642,10 +670,7 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
       if (pendingReviewResults(latest).some((entry) => entry.pr === pr && sameHead(entry.head, toHead))) {
         step('review', 'awaiting-review-result', 'exact-head review result pending', false);
       } else if (!latest.reviewRequests?.some((entry) => entry.pr === pr && sameHead(entry.head, toHead)) && deps.liveMoves.has('review')) {
-        const before = { reviewRequests: latest.reviewRequests, landAttempts: latest.landAttempts };
-        const result = await executeLiveReview(latest, pr, { runId: latest.runId ?? null, stopReason: 'queue-exact-head', cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
-        recordMove(statePath, latest.id, latest.runId, 'review', result, pr, before, now, deps.log);
-        step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
+        await requestReview(latest, 'queue-exact-head');
       } else step('review', 'not-landing', 'exact-head PASS/WARN mf0 review not captured', true);
       return outcomes;
     }
@@ -654,8 +679,13 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     const reviewResult = latest.reviewRequests?.find((entry) => entry.pr === pr && sameHead(entry.head, toHead) && entry.resultPath)?.resultPath;
     if (!reviewResult) { step('land', 'not-landing', 'exact-head review JSON path missing', true); return outcomes; }
     const before = { reviewRequests: latest.reviewRequests, landAttempts: latest.landAttempts };
+    if (deps.landBudget && deps.landBudget.requested >= deps.landBudget.max) {
+      step('land', 'tick-cap', `land attempt cap ${deps.landBudget.max} reached — next tick`, false);
+      return outcomes;
+    }
     const queued = await executeLiveLand(latest, pr, { runId: latest.runId ?? null, cycleId: `queue:${latest.id}:${toHead}`, cwd,
       review, reviewResultPath: reviewResult }, { ...live, landQueueConfig: queueMode, ...(deps.log ? { log: deps.log } : {}) });
+    if (deps.landBudget && queued.executed) deps.landBudget.requested++;
     recordMove(statePath, latest.id, latest.runId, 'propose-land', queued, pr, before, now, deps.log);
     step('land', queued.queued ? 'queued' : queued.ok && !queued.executed ? 'queue-skipped' : 'queue-refused', queued.detail, true);
     return outcomes;
@@ -778,12 +808,7 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
   // ② 리뷰 — 지금 머리로 요청한 적이 없으면 다시(같은 머리는 한 번 · 상한은 ① 의 머리 수가 이미 막았다).
   if (!reviews.some((entry) => sameHead(entry.head, toHead))) {
     if (!deps.liveMoves.has('review')) step('review', 'would-review', 'review not enabled in taskAgent.liveMoves — shadow', false);
-    else {
-      const before = { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts };
-      const result = await executeLiveReview(card, pr, { runId: card.runId ?? null, stopReason: 'rejudge-on-head', cwd }, { ...live, ...(deps.log ? { log: deps.log } : {}) });
-      recordMove(statePath, card.id, card.runId, 'review', result, pr, before, now, deps.log);
-      step('review', result.executed ? 'review-requested' : 'review-request-failed', result.detail, true);
-    }
+    else await requestReview(card, 'rejudge-on-head');
     return outcomes;
   }
   const latest = readTaskCard(card.id, statePath) ?? card;
@@ -828,10 +853,15 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     return outcomes;
   }
   const before = { reviewRequests: latest.reviewRequests, landAttempts: latest.landAttempts };
+  if (deps.landBudget && deps.landBudget.requested >= deps.landBudget.max) {
+    step('land', 'tick-cap', `land attempt cap ${deps.landBudget.max} reached — next tick`, false);
+    return outcomes;
+  }
   // 주기 id — base-stale 재게이트 뒤의 land 는 새 base 를 붙여 앞 land 의 주기 표시(모듈 전역)와 갈린다 · gateAt 이 앞 base-stale 시도를 소비한다.
   const cycleId = `rejudge:${card.id}:${toHead}${regate.staleBase ? `:${regate.baseCommit.slice(0, 12)}` : ''}`;
   const landed = await executeLiveLand(latest, pr, { runId: card.runId ?? null, cycleId, cwd, review, reviewResultPath: reviewResult, overlapEvidence, gateAt: regate.at },
     { ...live, ...(deps.log ? { log: deps.log } : {}) });
+  if (deps.landBudget && landed.executed) deps.landBudget.requested++;
   // LAND-ORDER-LEDGER — executeLiveLand 직후 원장 한 줄(같은 pr+head 는 한 줄만). 쓰기가 실패해도 land 결과는 그대로(삼킨다).
   const landOrderLog = (event: 'appended' | 'append-failed') => { try { log('task-agent.land-order', event, { pr, head: toHead }); } catch { /* fail-soft */ } };
   try {
@@ -844,6 +874,38 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
     landOrderLog('append-failed');
   }
   recordMove(statePath, card.id, card.runId, 'propose-land', landed, pr, before, now, deps.log);
+  if (landed.executed && !landed.ok && /^✗/.test(landed.detail)) {
+    const context = { refusal: landed.detail, pr, head: toHead };
+    const preliminary = planPrLandRecovery(context);
+    if (preliminary.result.action === 'request-review' || preliminary.result.action === 'wait-retry') {
+      const entry = preliminary.result.action;
+      try {
+        const graphPath = entry === 'request-review' ? '../../graphs/units/task-agent-recover-review.yaml' : '../../graphs/units/task-agent-recover-wait.yaml';
+        const graph = await runGraph(join(import.meta.dir, graphPath), {
+          input: { ask: `TA land refusal for PR #${pr}`, context, prior: {} },
+          pinChildUniverse: true,
+          deps: { root: dirname(statePath) },
+        });
+        const output = lastJsonObject(graph.nodes.find((node) => node.nodeId === 'recover')?.output);
+        const plan = graph.status === 'done' && graph.unitCalls?.[0]?.entry === entry
+          && graph.unitCalls[0].exit === 'rework' ? output as unknown as PrLandRecoveryPlan | undefined : undefined;
+        const action = plan?.result?.action;
+        const matched = plan?.outcome === 'rework' && plan.result.pr === pr && plan.result.head === toHead
+          && action === preliminary.result.action && plan.evidence?.refusal === context.refusal.slice(0, 500)
+          && (action !== 'wait-retry' || plan.result.delayMs === 30_000);
+        if (!matched) step('land', 'recover-untrusted', `recover@1 ${entry} produced no pinned matching action`, true);
+        else if (action === 'request-review' && deps.liveMoves.has('review')) {
+          await requestReview(readTaskCard(card.id, statePath) ?? card, 'land-refusal-review-missing', true);
+        } else if (action === 'request-review') {
+          step('review', 'recover-review-disabled', 'recover@1 selected review but taskAgent.liveMoves excludes review', true);
+        } else if (action === 'wait-retry') {
+          step('land', 'recover-wait-retry', `recover@1 ${entry} selected existing retry admission after ${plan.result.delayMs}ms`, true);
+        } else step('land', 'recover-needs-human', `recover@1 ${entry}: ${plan.result.reason}`, true);
+      } catch (error) {
+        step('land', 'recover-failed', `recover@1 ${entry}: ${String(error).slice(0, 200)}`, true);
+      }
+    }
+  }
   // TA-LAND-RETRY-ON-INFRA — 실패한 시도는 갈래·사유·재시도 여부를 사유 줄에 싣는다(다음 틱이 왜 다시 하는지/안 하는지).
   const attempt = landed.landAttempt?.class
     ? ` · land-class ${landed.landAttempt.class} (${landed.landAttempt.reason}) · attempt ${landed.landAttempt.attempt} · ${landed.landAttempt.class === 'base-stale' ? 'base-stale → re-gate on a new base next tick (cap counts)' : landed.landAttempt.retryAllowed ? 'retry allowed on this head' : 'no retry on this head'}`
@@ -862,11 +924,35 @@ function recordMove(statePath: string, cardId: string, runId: string | undefined
 }
 
 /** 재판정 대상 카드 — 기존 리뷰 또는 HQ 가 종결 원장을 검증할 원격 부모 카드. */
-export function rejudgeCandidates(tasks: Readonly<Record<string, TaskCard>>): string[] {
+export function rejudgeCandidates(tasks: Readonly<Record<string, TaskCard>>, opts: {
+  now?: Date; maxAgeHours?: number; onAgeSkip?: (card: TaskCard, ageHours: number | null) => void;
+  /** Fresh remote PR heads; mf0 only gets priority when it matches this head. */
+  currentHeads?: ReadonlyMap<string, string>;
+} = {}): string[] {
+  const now = opts.now?.getTime() ?? Date.now();
+  const maxAgeHours = opts.maxAgeHours;
   return Object.values(tasks).filter((card) => {
     const pr = cardPrNumber(card);
-    return pr !== undefined && !boundPrTerminal(card) && ((card.reviewRequests ?? []).some((entry) => entry.pr === pr)
+    const eligible = pr !== undefined && !boundPrTerminal(card) && ((card.reviewRequests ?? []).some((entry) => entry.pr === 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;
+    if (maxAgeHours !== undefined) {
+      const created = Date.parse(card.createdAt);
+      const ageHours = Number.isFinite(created) ? Math.max(0, (now - created) / 3_600_000) : null;
+      if (ageHours === null || ageHours > maxAgeHours) { opts.onAgeSkip?.(card, ageHours); return false; }
+    }
+    return true;
+  }).sort((a, b) => {
+    const hasMf0 = (card: TaskCard): number => {
+      const pr = cardPrNumber(card);
+      const head = card.reviewRequests?.filter((entry) => entry.pr === pr).at(-1)?.head;
+      const currentHead = opts.currentHeads?.get(card.id);
+      return pr !== undefined && head && currentHead?.toLowerCase() === head.toLowerCase()
+        && capturedLandReview(card, pr, head)?.mustFixCount === 0 ? 1 : 0;
+    };
+    const ageOrder = (Number.isFinite(Date.parse(b.createdAt)) ? Date.parse(b.createdAt) : 0)
+      - (Number.isFinite(Date.parse(a.createdAt)) ? Date.parse(a.createdAt) : 0);
+    return hasMf0(b) - hasMf0(a) || ageOrder || a.id.localeCompare(b.id);
   }).map((card) => card.id);
 }

package/src/task-agent/repair-branch-cas.ts

@@ -24,7 +24,8 @@ export interface RepairCasRequest {
   result: RepairCommitResult;
   /** A previous push succeeded. Confirmation may inspect the remote and PR, but must never push again. */
   confirmationOnly?: boolean;
-  branch?: string;
+  /** PR branch captured when this repair was requested. A rename cannot retarget its push. */
+  branch: string;
   /** Persist a single-use push intent after bundle/ancestry checks and before the push side effect. */
   claimBeforePush?: () => boolean;
 }
@@ -99,6 +100,8 @@ export function applyRepairBundle(request: RepairCasRequest, deps: RepairCasDeps
   try { bytes = readFileSync(bundlePath); } catch { return fail('repair bundle unreadable'); }
   if (createHash('sha256').update(bytes).digest('hex') !== result.bundleSha256.toLowerCase()) return fail('repair bundle sha256 mismatch');
   if (!initial || !originRepo || initial.headRepo.toLowerCase() !== originRepo) return fail('PR head repository differs from git origin');
+  if (!request.branch || git(['check-ref-format', '--branch', request.branch]).status !== 0) return fail('bound repair branch name invalid');
+  if (initial.branch !== request.branch) return fail('bound repair branch changed');
   const alreadyApplied = initial?.head.toLowerCase() === result.commit.toLowerCase();
   if (!initial || initial.state !== 'OPEN' || initial.crossRepository || (!alreadyApplied && initial.head.toLowerCase() !== expectedHead.toLowerCase()))
     return fail('PR head CAS mismatch or PR unavailable');

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

@@ -92,14 +92,15 @@ export async function repairModelAvailability(readInputs: () => Promise<Pick<Bud
   } catch { return { codexSubscription: false, grokSubscription: false }; }
 }
 
-/** Repair stays inside the dispatch tier. A missing legacy tier is high, with Sol allowed only on measured subscription quota. */
+/** Repair stays inside the dispatch tier. A missing legacy tier is mid ('중'); Sol is reserved for the 특 tier and measured-subscription 상 repairs. */
 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' };
   const sol: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-sol' };
   const grok: TaskChildLlm = { provider: 'grok', model: 'grok-4.6' };
-  const tier = card.tier ?? '상';
+  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;
@@ -108,6 +109,8 @@ export function alternateRepairModel(card: TaskCard, availability: RepairModelAv
   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;
   return { from, to };
@@ -192,7 +195,7 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
         const bundlePath = join(artifactDir, 'commit.bundle');
         let pushClaimed = false;
         applied = (input.apply ?? applyRepairBundle)({ repo, pr, expectedHead: latest.head,
-          bundlePath, result: result.result,
+          bundlePath, result: result.result, branch: latest.branch,
           claimBeforePush: () => {
             let claimed = false;
             updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === latest.runId && entry.status === 'requested')
@@ -308,6 +311,16 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       ? { ...current, repairs: current.repairs.map((entry) => entry.runId === runId ? { ...entry, status: 'failed' as const, detail: reason } : entry) } : undefined);
     return { decision: 'repair-failed', reason };
   }
+  // The request may throw before a worker exists. A post-launch observation
+  // failure must not turn an accepted worker into a failed launch.
+  try {
+    updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === runId)
+      && !current.history.some((entry) => entry.event === 'harness.role-llm' && entry.runId === runId)
+      ? { ...current, history: [...current.history, { at: now.toISOString(), event: 'harness.role-llm', pr, head, runId,
+        detail: `repair child model ${to.provider}/${to.model}` }] } : undefined);
+  } catch (error) {
+    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);
     else {

package/src/task-agent/run-identity.ts

@@ -6,7 +6,8 @@
  *   디스패처 배선은 RUN-IDENTITY-ADMIT).
  * - parse/validate: 목록 밖 값은 거부한다(조용히 다듬지 않는다).
  * - 출생 신분 자동(`deriveBirthIdentity`): 칸 우선순위(P0 = critical·special·protect ·
- *   P1 = normal · 그 외 normal)·대표 표시에서 단다.
+ *   P1 = normal · 그 외 normal)·대표 표시에서 단다. 권한(rights)은 명시 `--tag rights=…`만 기록한다
+ *   (RUN-IDENTITY-RIGHTS — 체크리스트에는 권한 근거가 없으므로 출생값으로 추정하지 않는다).
  * - 태그 덮기(`applyRunIdentityTags`): `tasks hand --tag k=v`(반복) 이 출생 신분을 덮는다.
  * - ⛔ 모르는 칸을 기본값으로 확정하지 않는다: 칸 조회가 실패하면 명시 태그만 담고 나머지는 «미기록».
  * - 태그 바꾸기 감사(`runTagChange` — task-hand.ts): 카드 history 에 `run-tag-change`
@@ -129,7 +130,8 @@ const CROWN_MARK = '\u{1F451}';
 
 /**
  * 출생 신분 자동 — «조회에 성공한» 칸의 우선순위(P0 = critical·special·protect · P1 = normal · 그 외 normal)·대표 표시에서 단다.
- * 권한(rights)은 출생에서 올리지 않는다(기본 s · 올림은 `--tag rights=…` 명시만).
+ * 권한(rights)은 추정하지 않는다(RUN-IDENTITY-RIGHTS): 체크리스트 출생 정보에는 권한 근거가 없으므로
+ * `--tag rights=…` 명시 태그로만 기록하고, 태그가 없으면 «미기록».
  * ⛔ 칸을 못 읽었으면 부르지 않는다 — 그때는 `{ origin }` 에 명시 태그만 얹는다(나머지 «미기록»).
  * ⛔ 읽은 칸이라도 `priority`·`title` 이 비면 그 값에서 파생되는 칸을 확정하지 않는다(«미기록»):
  *   class 는 priority 가 있어야 · care·protect 는 P0 이거나 대표 가 보이면 올리고, «안 올림»(standard·false)은
@@ -145,7 +147,6 @@ export function deriveBirthIdentity(cell: RunIdentityCell, origin: RunIdentityOr
   return {
     ...(priority !== undefined ? { class: critical ? 'critical' as const : 'normal' as const } : {}),
     ...(careKnown ? { care: raised ? 'special' as const : 'standard' as const, protect: raised } : {}),
-    rights: 's',
     origin,
   };
 }

package/src/task-agent/shadow.ts

@@ -15,6 +15,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 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 { 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';
@@ -327,14 +329,22 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       checklistId: delivery ? card?.checklistId ?? '' : '',
       ...(delivery ? { delivery } : {}),
     };
-    const liveRetry = !delivery && deps.command !== undefined && deps.loadGate !== undefined
-      && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move) && liveMoves.has(judgement.move as TaskAgentLiveMove);
+    const retryMove = !delivery && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move);
+    const route = retryMove ? readJourneyEdge('next-move', judgement.move,
+      { 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, {
       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; },
       ...(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');
+    }
   }
   const move: TaskAgentShadowMove = {
     runId: input.runId,

package/src/task-agent/task-hand.ts

@@ -10,7 +10,7 @@
 import { execFileSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync, statSync, writeFileSync, type Stats } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, posix, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import { validateUnitCalls } from '../graph-runner/runner.js';
@@ -29,7 +29,8 @@ import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type Work
 import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDoneCandidate,
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftReleaseComment } from '../self-dev/draft-triage-rules.js';
-import { parseAskTargetPathHints } from '../self-dev/launch-preflight-text.js';
+import { parseAskTargetPathHints, parseAskTargetPathHintsResult } from '../self-dev/launch-preflight-text.js';
+import { inspectGoalDoneBoundary } from '../self-implement/goal-author.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
 
 export interface ResolveHandTextDeps {
@@ -210,6 +211,8 @@ export interface TaskCardMove { kind: 'launch' | 'wait'; command?: string[]; rea
 export interface TaskCard {
   id: string;
   text: string;
+  /** 첫 줄 대상 경로 라벨에서 확인한 저장소 상대 경로. 필드 부재는 경로를 모른다는 뜻이다. */
+  targetPaths?: string[];
   seat?: TaskSeat;
   checklistId?: string;
   /** Explicit release version for an adopted PR; post-land still confirms the cell exists there. */
@@ -231,8 +234,11 @@ export interface TaskCard {
    * launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사.
    * failed = 발사된 런이 PR·수확 가지 없이 죽었거나 끝내 안 떴다(TA-JUDGE-DEAD-RUN · `card-evidence.ts`) — 사유
    * (`failed/needs-owner|needs-relaunch — …`)는 history 마지막 칸 · 자동 재발사하지 않는다(사람/판단부 몫).
+   * landed-by-hand = 실패 카드에 묶인 PR을 사람이 손수 병합해 main 에 안착시켰다(TA-CARD-MERGE-RECONCILE ·
+   * `postland-card.ts` `reconcileHandMergedCard`) — 이전 status·사유는 history `hand-move` 줄에 보존된다.
+   * landed = 병합된 merge 커밋이 카드의 land attempt head 와 정확히 일치해 에이전트 착지로 확정했다(같은 정산 경로).
    */
-  status: 'handed' | 'launched' | 'launch-failed' | 'failed' | 'done';
+  status: 'handed' | 'launched' | 'launch-failed' | 'failed' | 'landed-by-hand' | 'landed' | 'done';
   history: TaskCardEvent[];
   /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
   pieces?: string[];
@@ -292,7 +298,7 @@ export interface TaskCard {
    * REJUDGE base-stale — `base-stale` (overlap evidence gate base went stale with PR-file overlap) waits for a re-gate on a new base;
    * only after that re-gate passes is the attempt consumed (`openLandAttempts`) and the same head may land once more.
    */
-  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string; class?: 'infra' | 'judgement' | 'base-stale'; reason?: string }>;
+  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string; class?: 'infra' | 'judgement' | 'base-stale' | 'recovery'; reason?: string }>;
   /** TA-LIVE-LAND-2 — `tasks hand --ta-land`: this card's run leaves the merge to the task agent (propose-land). */
   taLand?: true;
   /** TASKS-HAND-CHILD-LLM — `tasks hand --child-llm <provider>/<model> [--child-llm-effort <level>]` → 발사 인자 `--child-llm-provider/-model/-effort`. */
@@ -434,6 +440,25 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+function canonicalTargetPaths(paths: readonly string[]): string[] {
+  return [...new Set(paths.filter((path): path is string => typeof path === 'string').map((path) => posix.normalize(path))
+    .filter((path) => path !== '.' && path !== '..' && !posix.isAbsolute(path)
+      && !path.startsWith('../') && !path.includes('\\') && !/^[A-Za-z]:\//.test(path)))].sort();
+}
+
+/** 같은 저장소 경로를 만지는 착지 전 카드만 돌려준다. 경로 미기록 카드는 추측하지 않는다. */
+export function cardsTouchingPaths(cards: readonly TaskCard[], paths: readonly string[]): Array<{
+  card: TaskCard; checklistId?: string; runId?: string; pr?: number; paths: string[];
+}> {
+  const wanted = new Set(canonicalTargetPaths(paths));
+  if (wanted.size === 0) return [];
+  return cards.filter((card) => card.status === 'launched' && !card.postLand && !card.trainLanding && !card.prTerminal)
+    .map((card) => ({ card, paths: canonicalTargetPaths(card.targetPaths ?? []).filter((path) => wanted.has(path)) }))
+    .filter((item) => item.paths.length > 0)
+    .map(({ card, paths }) => ({ card, ...(card.checklistId ? { checklistId: card.checklistId } : {}),
+      ...(card.runId ? { runId: card.runId } : {}), ...(cardPrNumber(card) !== undefined ? { pr: cardPrNumber(card) } : {}), paths }));
+}
+
 export const CLOSED_BY_HAND_EVENT = 'closed-by-hand';
 
 /** 카드를 손으로 닫는다 — 상태를 `failed` 로 두고 history 에 한 줄(`closed-by-hand`)을 남긴다. 이미 손으로 닫은 카드는 그대로 돌려준다(멱등). */
@@ -552,7 +577,7 @@ export function shellQuote(arg: string): string {
 }
 
 /** 발사기에 넘기는 연결 — env(`ELANOUS_RUN_ID`)를 자식 환경에 얹으면 하니스 런이 `runId` 로 돈다(`resolveRunIdentity` 상속). launchId 는 카드에만 남는 발사 토큰이다. */
-export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string>; cardLabelContext?: TaskCardLabelContext }
+export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string>; cardLabelContext?: TaskCardLabelContext; substrate?: 'pod'; podGoal?: string; effectiveChildProvider?: string }
 /** 발사기가 «이 런 id 로 띄웠다»고 돌려주는 영수증 — 없으면 카드에 런 id 를 적지 않는다(추측하지 않는다). */
 export interface TaskLaunchReceipt {
   runId?: string;
@@ -657,6 +682,8 @@ export function dispatchDeliverableCompletion(id: string, input: { ref: string;
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const text = opts.text.trim();
   if (!text) throw new Error('과제 한 줄이 비어 있다');
+  const targetPathHints = parseAskTargetPathHintsResult(text);
+  const targetPaths = canonicalTargetPaths(targetPathHints.paths);
   if (opts.seat !== undefined && !TASK_SEATS.includes(opts.seat)) throw new Error(`자리는 ${TASK_SEATS.join('|')} 중 하나다: ${opts.seat}`);
   if (opts.completion !== undefined && !COMPLETION_KINDS.includes(opts.completion)) throw new Error(`종결 종류는 ${COMPLETION_KINDS.join('|')} 중 하나다: ${opts.completion}`);
   for (const [flag, value] of [['--goal', opts.goal], ['--milestone', opts.milestone]] as const) {
@@ -708,6 +735,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const path = opts.statePath ?? taskAgentStatePath();
   const card: TaskCard = {
     id, text,
+    ...(!targetPathHints.labelMissing ? { targetPaths } : {}),
     ...(opts.seat ? { seat: opts.seat } : {}),
     ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
     ...(opts.checklistVersion !== undefined ? { checklistVersion: opts.checklistVersion } : {}),
@@ -748,6 +776,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (!owned.ok) throw new TaskCardSupersededError(next.id);
   };
   writeCard(path, card);
+  try { debug.log('task-agent.hand', 'target-paths', { card: id, count: targetPaths.length, labelMissing: targetPathHints.labelMissing }); } catch { /* fail-soft */ }
   try { debug.log('task-agent.graph-select', !selected.composition ? 'composition-missing' : selected.error ? 'composition-invalid' : 'composition-selected', {
     completion, file: selected.composition?.file ?? `graphs/work/${completion}.yaml`,
     unitsResolved: selected.unitsResolved, missingUnits: selected.missingUnits,
@@ -761,6 +790,17 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   }
   if (mode === 'shadow') return { card, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
+  if (completion === 'code-pr' && card.checklistId) {
+    const { missing } = inspectGoalDoneBoundary(text);
+    if (missing.length > 0) {
+      const reason = `goal-revision-required: 완료 경계 누락 ${missing.join(' · ')} — 골 문면을 고친 뒤 다시 넘기세요`;
+      const failed: TaskCard = { ...card, status: 'failed', history: [...card.history,
+        { at: (opts.now ?? (() => new Date()))().toISOString(), event: 'goal-revision-required', detail: reason }] };
+      writeCard(path, failed);
+      try { debug.log('task-agent.hand', 'done-boundary-missing', { taskId: id, checklistId: card.checklistId ?? null, missing, reason }); } catch { /* fail-soft */ }
+      throw new Error(`${reason} (카드 ${id})`);
+    }
+  }
   let prelaunch: AlreadyDoneDecision;
   try { prelaunch = completion === 'code-pr'
     ? (opts.prelaunchInspector ?? ((input, target) => inspectPrelaunchAlreadyDone(input, target,
@@ -779,9 +819,14 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const runId = mintRunId();
   const launchId = `tl-${randomBytes(6).toString('hex')}`;
   const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id,
+    ...(cardPrNumber(card) ? { ELANOUS_TASK_BOUND_PR: String(cardPrNumber(card)) } : {}),
     ...(card.checklistId ? { ELANOUS_POD_SLOT_ID: card.checklistId } : {}),
     ...(card.seat ? { ELANOUS_POD_OWNER_KIND: 'seat', ELANOUS_POD_OWNER_ID: card.seat } : {}),
-    ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
+    ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card),
+    // An omitted card provider uses the established Pod default. Carry the effective value explicitly so
+    // remote-parent code never has to infer a provider from the serialized CLI argv.
+    effectiveChildProvider: card.childLlm?.provider ?? 'openai-codex',
+    ...(completion === 'code-pr' && selected.launcher === 'harness-say' ? { substrate: 'pod' as const, podGoal: card.text } : {}) };
   let receipt: void | TaskLaunchReceipt;
   try {
     receipt = await opts.launcher(move.command!, project?.target, context);
@@ -812,9 +857,11 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   // INFLIGHT-REGISTRY — 출발 때 맥락을 남긴다(머지 때 같은 파일 줄의 의도를 스마트 머지가 읽는다 · 착지하면 지운다).
   try {
     const [head = '', ...rest] = text.split(/\r?\n/);
+    const intentLines = (/^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]/i.test(head) ? rest : [head, ...rest])
+      .filter((line) => !/^\s*(?:[-*]\s*)?완료 경계 (?:코드|실물|증거 명령)\s*:/.test(line));
     registerInflight({
       runId: boundRunId ?? runId, cell: card.checklistId ?? card.id, cardId: card.id,
-      intent: (/^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]/i.test(head) ? rest.join(' ') : text) || text,
+      intent: intentLines.join(' ').trim() || text,
       files: parseAskTargetPathHints(text),
     }, { path: join(dirname(path), INFLIGHT_REGISTRY_FILE), ...(opts.now ? { now: opts.now } : {}) });
   } catch (error) {

package/src/task-agent/work-order-build.ts

@@ -0,0 +1,22 @@
+import { parseWorkOrder, type WorkOrder } from './work-order.js';
+
+export interface BuildWorkOrderInput {
+  cellId: string;
+  version: string;
+  lifeId?: string;
+  priority?: string;
+  peers?: string;
+}
+
+/** Build the normalized nine-field core from already-grounded inputs; no CLI, filesystem, or launch side effects. */
+export function buildWorkOrder(input: BuildWorkOrderInput): WorkOrder {
+  const parsed = parseWorkOrder(JSON.stringify({
+    cellId: input.cellId,
+    lifeId: input.lifeId,
+    version: input.version,
+    priority: input.priority,
+    peers: input.peers,
+  }));
+  if (!parsed.ok) throw new Error(parsed.reason);
+  return parsed.order;
+}

package/src/task-orchestrator/surfaces/pod-account-broker.ts

@@ -17,6 +17,17 @@ export type PodProviderPlan =
   | { provider: 'grok'; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean }
   | { provider: null; reasons: string[]; grokSubscriptionEligible: boolean };
 
+/** Effective cap used by the Pod broker; callers carrying an owner-approved selection must carry this same value. */
+export function podAccountThresholdPercent(name: string, options: {
+  excludeAt?: number;
+  thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
+} = {}): number {
+  return codexAccountThresholdPercent(name, {
+    thresholdPercent: options.excludeAt ?? POD_ACCOUNT_EXCLUDE_AT_PERCENT,
+    thresholdPercentByAccount: options.thresholdPercentByAccount,
+  });
+}
+
 /** Pod 의 codex → grok 선택. 자격 종류는 과금 동의와 별도로 판단한다. */
 export function planPodProvider(input: {
   codexCandidates: readonly RotationCandidate[];
@@ -85,9 +96,7 @@ export function planPodAccounts(
   const known: RotationCandidate[] = [];
   const unknown: RotationCandidate[] = [];
   for (const c of candidates) {
-    const threshold = typeof options === 'number'
-      ? excludeAt
-      : codexAccountThresholdPercent(c.name, { thresholdPercent: excludeAt, thresholdPercentByAccount });
+    const threshold = typeof options === 'number' ? excludeAt : podAccountThresholdPercent(c.name, { excludeAt, thresholdPercentByAccount });
     if (c.reached === true) { excluded.push({ name: c.name, why: 'quota reached' }); continue; }
     if (c.usedPercent !== undefined && c.usedPercent >= threshold) { excluded.push({ name: c.name, why: `used ${c.usedPercent}% ≥ ${threshold}%` }); continue; }
     (c.usedPercent === undefined ? unknown : known).push(c);
@@ -113,6 +122,33 @@ export function planPodAccounts(
   return { usable, excluded };
 }
 
+/** HQ selects one owner account before remote-parent launch; keep the configured rotation order. */
+export function planOwnerCodexMirrorCandidates(candidates: readonly RotationCandidate[], options: {
+  accountOrder: readonly string[];
+  thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
+}): RotationCandidate[] {
+  const usable = new Set(planPodAccounts(candidates, { thresholdPercentByAccount: options.thresholdPercentByAccount }).usable);
+  const rank = (name: string): number => {
+    const index = options.accountOrder.indexOf(name);
+    return index < 0 ? options.accountOrder.length : index;
+  };
+  return candidates.map((candidate, index) => ({ candidate, index })).filter(({ candidate }) => usable.has(candidate.name))
+    .sort((a, b) => rank(a.candidate.name) - rank(b.candidate.name) || a.index - b.index)
+    .map(({ candidate }) => candidate);
+}
+
+/** Remote owner-mirror runs may plan against exactly the account HQ selected and its measured usage. */
+export function ownerCodexMirrorCandidate(candidates: readonly RotationCandidate[], account: string, usedPercent?: number): RotationCandidate[] {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(account)) return [];
+  return candidates.filter((candidate) => candidate.name === account).map((candidate) => {
+    const ownerCandidate = { ...candidate };
+    delete ownerCandidate.usedPercent;
+    ownerCandidate.reached = false;
+    const measured = usedPercent !== undefined && Number.isFinite(usedPercent) ? usedPercent : undefined;
+    return { ...ownerCandidate, reached: false, ...(measured !== undefined ? { usedPercent: measured } : {}) };
+  });
+}
+
 /** Job 마다 다음 계정 — 잔량 순으로 돌려 가며. 쓸 계정이 없으면 만들 때 이유를 대고 던진다. */
 export function makePodAccountBroker(plan: PodAccountPlan): () => string {
   if (plan.usable.length === 0) {