elanous 0.2.28 → 0.2.29

package/src/skills/tools/persistent-grounding.ts

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import { realpath } from 'node:fs/promises';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool, type GoalLoopOptions } from '../../core-turn/index.js';
+import { runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool, type GoalLoopOptions, type GoalLoopResult } from '../../core-turn/index.js';
 import { debug } from '../../debug/log.js';
+import { selectPlanningLlm } from '../../prompt-enhance/enhance.js';
 import type { LLMMessage, LLMToolSpec } from '../../llm.js';
 import { buildAstGrepTool, dispatchAstGrep, hasAstGrep } from './ast-grep.js';
 import { buildGlobTool, dispatchGlob } from './glob.js';
@@ -22,6 +23,8 @@ export interface PersistentGroundingDeps {
   relativePath?: (from: string, to: string) => string;
   /** Terms generated by an upstream grounding consumer; the loop must prioritize them for code discovery. */
   terms?: string[];
+  /** Authoring model selection seam; production follows the planning role, including the Pod relay. */
+  planningLlm?: () => Pick<ReturnType<typeof selectPlanningLlm>, 'model' | 'modelSource' | 'fallbackReason' | 'requestedModel' | 'requestedSource'>;
 }
 
 export interface PersistentGroundingResult {
@@ -215,7 +218,7 @@ function groundingMessages(goal: string, terms: readonly string[]): LLMMessage[]
 function unreadEvidencePaths(evidence: string, readFiles: ReadonlySet<string>): string[] {
   return Array.from(new Set(evidence.split(/\r?\n/)
     .flatMap(repositoryRelativeCodePaths)
-    .filter((path) => isCodeRootPath(path) && !readFiles.has(path)))).slice(0, 8);
+    .filter((path) => isCodeRootPath(path) && !readFiles.has(path))));
 }
 
 function rejectedEvidenceFeedback(evidence: string, readFiles: ReadonlySet<string>): LLMMessage {
@@ -224,10 +227,11 @@ function rejectedEvidenceFeedback(evidence: string, readFiles: ReadonlySet<strin
   return {
     role: 'user',
     content: [
-      'Your completion evidence was rejected because it cited a repository path that Read did not verify.',
+      'Your completion evidence was rejected: Glob, Grep, and ListDir prove discovery, but they do not verify a file for completion evidence.',
       `Unverified paths: ${unread.length ? unread.join(', ') : '(none in allowed code roots)'}`,
       `Paths actually Read: ${read.length ? read.join(', ') : '(none)'}`,
-      'Try once more. Read each relevant unverified path before citing it, or remove it from the evidence. Cite only repository-relative code paths that this grounding run actually Read, each with a concrete reason. If no path is relevant, do not invent evidence.',
+      ...(unread.length ? [`Next tool calls: ${unread.map((path) => `Read({"file_path":"${path}"})`).join(' ; ')}`] : []),
+      'Before calling update_goal(status="complete"), Read at least one relevant path above and wait for its successful result. Cite only paths that this grounding run actually Read, each with a concrete reason. If a Read fails, omit that path. Finish by calling update_goal; ending with prose alone does not complete this task.',
     ].join('\n'),
   };
 }
@@ -248,7 +252,10 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
   if (!astGrepAvailable) debug.log('grounding.persistent', 'tool-unavailable', { sessionId, tool: 'AstGrep' }, { level: 'warn' });
   const toolCalls: Record<string, number> = {};
   let completedIterations: number | undefined;
+  let resolvedProvider: string | undefined;
+  let resolvedModel: string | undefined;
   try {
+    const planningLlm = (deps.planningLlm ?? selectPlanningLlm)();
     const loop = deps.runGoalLoop ?? runGoalLoop;
     let completionEvidence = '';
     const readFiles = new Set<string>();
@@ -259,7 +266,12 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
       dispatchTool: guardedDispatchTool(cwd, deps.dispatchTool, readFiles, deps.relativePath),
       signal: new AbortController().signal,
       maxToolTurns: 4,
+      ...(planningLlm.model ? { modelOverride: planningLlm.model } : {}),
       callbacks: {
+        onResolvedProvider: (provider, model) => {
+          resolvedProvider = provider;
+          resolvedModel = model;
+        },
         onToolCall: (call) => {
           toolCalls[call.name] = (toolCalls[call.name] ?? 0) + 1;
           if (call.name === 'update_goal' && call.args.status === 'complete' && typeof call.args.evidence === 'string') completionEvidence = call.args.evidence;
@@ -282,6 +294,8 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
     let verified = firstVerified;
     let feedbackRetry = false;
     let retryIterations = 0;
+    let retryStopReason: GoalLoopResult['stopReason'] | undefined;
+    let retryOutcome: 'not-needed' | 'verified' | 'incomplete' | 'evidence-rejected' | 'failed' | 'aborted' | 'auth-rejected' = 'not-needed';
     if (firstVerified.rejection.notRead > 0) {
       feedbackRetry = true;
       const feedback = rejectedEvidenceFeedback(completionEvidence, readFiles);
@@ -290,6 +304,11 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
         const retry = await loop({ ...ctx, sessionId: `${sessionId}-evidence-retry`, messages: [...ctx.messages, feedback] },
           { ...options, maxIterations: 2 });
         retryIterations = retry.iterations;
+        retryStopReason = retry.stopReason;
+        retryOutcome = retry.goalComplete && retry.stopReason === 'goal_complete' ? 'evidence-rejected'
+          : retry.stopReason === 'auth_rejected' ? 'auth-rejected'
+            : retry.stopReason === 'aborted' || retry.stopReason === 'soft_stop' ? 'aborted'
+              : retry.stopReason === 'error' ? 'failed' : 'incomplete';
         const retryVerified = retry.goalComplete && retry.stopReason === 'goal_complete'
           ? verifiedEvidenceFromCompletion(completionEvidence, readFiles)
           : null;
@@ -300,8 +319,10 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
             rejection: retryVerified.rejection,
           };
           result = retry;
+          if (retryVerified.evidence.length > 0) retryOutcome = 'verified';
         }
       } catch (error) {
+        retryOutcome = 'failed';
         try {
           debug.log('grounding.persistent', 'evidence-retry-failed', { sessionId,
             reason: error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200) }, { level: 'warn' });
@@ -311,22 +332,41 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
       }
     }
     const totalIterations = first.iterations + retryIterations;
+    let stopReason: string = result.stopReason;
+    // A verified line remains useful evidence, but it cannot turn an unsuccessful
+    // feedback retry into a successful completion of the whole grounding task.
+    switch (retryOutcome) {
+      case 'incomplete': stopReason = 'evidence_retry_incomplete'; break;
+      case 'evidence-rejected': stopReason = 'evidence_retry_rejected'; break;
+      case 'failed': stopReason = retryStopReason === 'error' ? 'error' : 'evidence_retry_failed'; break;
+      case 'auth-rejected': stopReason = 'auth_rejected'; break;
+      case 'aborted': stopReason = retryStopReason === 'soft_stop' ? 'soft_stop' : 'aborted'; break;
+    }
     try {
       debug.log('grounding.persistent', 'finished', {
         sessionId,
         maxIterations,
         durationMs: durationMs(),
       iterations: totalIterations,
-      stopReason: result.stopReason,
+      stopReason,
       // ⛔ 「끝났다」가 두 뜻이다 — ⓐ 스스로 목표를 끝냈다 ⓑ 턴이 «그냥» 끝났다.
       //   📏 2026-08-11 72차 전수(400건): 후보 0인 finished 가 5건이고 ***다섯 다 end_turn*** 이었다.
       //   그 둘을 한 이름에 두면 「접지는 성공인데 코드가 0」이라는 «없는 수수께끼»가 생긴다.
-      outcome: result.goalComplete && result.stopReason === 'goal_complete' ? 'goal-complete' : 'stopped-without-goal',
+      outcome: result.goalComplete && stopReason === 'goal_complete' ? 'goal-complete' : 'stopped-without-goal',
       candidates: verified.files,
       candidateCount: verified.files.length,
       evidenceCount: verified.evidence.length,
       evidenceRejection: verified.rejection,
       feedbackRetry,
+        retryOutcome,
+        retryStopReason: retryStopReason ?? null,
+        provider: resolvedProvider ?? null,
+        model: resolvedModel ?? null,
+        planningModel: planningLlm.model ?? null,
+        planningModelSource: planningLlm.modelSource,
+        planningFallbackReason: planningLlm.fallbackReason ?? null,
+        planningRequestedModel: planningLlm.requestedModel ?? null,
+        planningRequestedSource: planningLlm.requestedSource ?? null,
       ...(feedbackRetry ? { firstEvidenceRejection: firstVerified.rejection } : {}),
         toolCalls,
       });
@@ -337,7 +377,7 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
       files: verified.files,
       evidence: verified.evidence,
       iterations: totalIterations,
-      stopReason: result.stopReason,
+      stopReason,
     };
   } catch (error) {
     try {

package/src/skills/tools/shell.ts

@@ -178,6 +178,116 @@ function rejectedCdResult(): RunShellDispatchResult {
   };
 }
 
+// ── ops-ledger CLI steering (RunShell-0 convergence) ────────────────────────
+// The durable mailbox and release-checklist ledgers have in-process native
+// tools (MsgList/MsgPost/MsgAck · ChecklistList/Add/Set/Move —
+// src/skills/tools/ops-ledger.ts, registered for the same skill+tui hosts as
+// RunShell). Shelling out to the `elanous` CLI for exactly those covered ops
+// pays 1.3–2s of process startup for work the host process does in <300ms,
+// and the CLI's human-oriented stdout amplifies TUI screen defects — so the
+// call is steered to the native tool with a structured refusal naming it.
+//
+// Deliberately NOT a blanket elanous-CLI ban: only the seven covered ops are
+// refused, and argv that explicitly scopes another universe (--test /
+// --config-dir / --state-dir) is allowed through because the native tools
+// always serve THIS process's instance.
+const LEDGER_CLI_BIN = /(?:^|[/\\])(?:elanous|elanous\.mjs|elanous\.cjs|eln)$/;
+const LEDGER_ENV_BIN = /(?:^|[/\\])env$/;
+const LEDGER_CLI_NATIVE_TOOL: Readonly<Record<string, string>> = {
+  'msg list': 'MsgList',
+  'msg post': 'MsgPost',
+  'msg ack': 'MsgAck',
+  'release checklist list': 'ChecklistList',
+  'release checklist add': 'ChecklistAdd',
+  'release checklist set': 'ChecklistSet',
+  'release checklist move': 'ChecklistMove',
+};
+
+/** The covered ops-ledger CLI op in this argv and its exposed native tool,
+ *  or null when the command should run normally. */
+export function matchLedgerCli(
+  command: readonly string[], availableToolNames: readonly string[] = [],
+): { covered: string; tool: string } | null {
+  let binIndex = 0;
+  // RunShell receives argv, so recognize only argv-preserving env wrappers.
+  // An alternate instance must still run its own CLI, never this process's native tool;
+  // so must a changed or unset ELANOUS_TRACK — the native tools record THIS process's
+  // seat as the actor and route ChecklistMove permissions by it.
+  if (LEDGER_ENV_BIN.test(command[0] ?? '')) {
+    binIndex = 1;
+    while (binIndex < command.length) {
+      const arg = command[binIndex]!;
+      if (arg === '-i' || arg === '--ignore-environment') return null;
+      if (arg === '--') { binIndex += 1; continue; }
+      if (arg === '-u' || arg === '--unset') {
+        const name = command[binIndex + 1];
+        if (!name || /^ELANOUS_(?:STATE_DIR|CONFIG_DIR|TEST_STATE_DIR|TRACK)$/.test(name)) return null;
+        binIndex += 2;
+        continue;
+      }
+      if (arg.startsWith('--unset=')) {
+        if (/^--unset=ELANOUS_(?:STATE_DIR|CONFIG_DIR|TEST_STATE_DIR|TRACK)$/.test(arg)) return null;
+        binIndex += 1;
+        continue;
+      }
+      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(arg)) {
+        if (/^ELANOUS_(?:STATE_DIR|CONFIG_DIR|TEST_STATE_DIR|TRACK)=/.test(arg)) return null;
+        binIndex += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  if (command[binIndex] === 'bun' || command[binIndex] === 'bunx' || command[binIndex] === 'node' || command[binIndex] === 'npx') {
+    binIndex += 1;
+    if (command[binIndex] === '--bun') binIndex += 1;
+  }
+  if (!LEDGER_CLI_BIN.test(command[binIndex] ?? '')) return null;
+  const args = command.slice(binIndex + 1);
+  if (args.some((arg) => arg === '--test' || arg === '--config-dir' || arg.startsWith('--config-dir=')
+    || arg === '--state-dir' || arg.startsWith('--state-dir=')
+    || arg === '--test-state-dir' || arg.startsWith('--test-state-dir='))) return null;
+  let i = 0;
+  while (i < args.length && args[i]!.startsWith('-')) i += 1;
+  const sub = args[i];
+  const covered = sub === 'msg'
+    ? `msg ${args[i + 1]}`
+    : sub === 'release' && args[i + 1] === 'checklist'
+      ? `release checklist ${args[i + 2]}`
+      : '';
+  const tool = covered ? LEDGER_CLI_NATIVE_TOOL[covered] : undefined;
+  if (!tool || !availableToolNames.includes(tool)) return null;
+  return { covered, tool };
+}
+
+function ledgerCliSteerOutput(shellTool: string, covered: string, tool: string): string {
+  const metadata = covered === 'release checklist set' ? ' — for owner/priority/disposition/kind/… use ChecklistEdit, one field per call' : '';
+  return `${shellTool} rejected \`${covered}\`: call the native ${tool} tool instead (same ledger, same permissions and audit, no CLI startup)${metadata}.`;
+}
+
+/** Structured refusal steering a covered ops-ledger CLI argv to its native
+ *  tool, or null when the command should run normally. Exported so tests
+ *  can exercise the matcher without spawning anything. */
+export function rejectedLedgerCliResult(
+  command: readonly string[], availableToolNames: readonly string[] = [],
+): RunShellDispatchResult | null {
+  const match = matchLedgerCli(command, availableToolNames);
+  if (!match) return null;
+  const { covered, tool } = match;
+  return {
+    output: ledgerCliSteerOutput('RunShell', covered, tool),
+    exitCode: null,
+    outcome: 'spawn-error',
+    elapsedMs: 0,
+    stdout: '',
+    stderr: `use the native ${tool} tool instead of the ${covered} CLI`,
+    truncated: false,
+    approvalKey: 'rejected:ops-ledger-cli',
+    sandboxed: false,
+    sandboxTool: 'none',
+  };
+}
+
 function logShellDispatch(event: string, data: Record<string, unknown>): void {
   debug.log('shell.dispatch', event, data);
 }
@@ -240,7 +350,7 @@ export function enqueueShellCompletionNotice(
 
 export async function dispatchRunShell(
   rawArgs: Record<string, unknown>,
-  opts: { signal?: AbortSignal } = {},
+  opts: { signal?: AbortSignal; availableToolNames?: readonly string[] } = {},
 ): Promise<RunShellDispatchResult> {
   const command = asCommand(rawArgs.command);
   const cwd = typeof rawArgs.cwd === 'string' ? rawArgs.cwd : undefined;
@@ -255,6 +365,12 @@ export async function dispatchRunShell(
     logShellDispatch('cd.rejected', { reason: 'argv-state-does-not-persist' });
     return rejectedCdResult();
   }
+  const ledgerCliMatch = matchLedgerCli(command, opts.availableToolNames);
+  if (ledgerCliMatch) {
+    // covered op ⊕ tool only — the argv can carry a message body.
+    logShellDispatch('ledger-cli.steered', { shell: 'run-shell', ...ledgerCliMatch });
+    return rejectedLedgerCliResult(command, opts.availableToolNames)!;
+  }
   const effectiveCwd = cwd ?? getSessionCwd();
   const cwdSource = cwd === undefined ? 'session' : 'argument';
   const boundaryReject = harnessCommandWriteReject(command, effectiveCwd, 'run-shell');

package/src/status/bar.ts

@@ -213,6 +213,9 @@ export interface GitSegmentState {
   ahead?: number;
   /** Commits behind upstream. Non-zero → peach tone with "-N". */
   behind?: number;
+  /** Optional axis label after the glyph (e.g. `트리`) — set when a
+   *  running-build pill sits next to it so the two SHAs are not confused. */
+  label?: string;
 }
 
 /** Git state — flat colored text. No pill background.
@@ -241,7 +244,7 @@ export function gitSegment(
   const head = state.branch
     ? truncateGitHead(state.branch, 20)
     : `HEAD@${(state.detachedSha ?? '').slice(0, 7)}`;
-  const parts: string[] = [`⌥ ${head}`];
+  const parts: string[] = [state.label ? `⌥ ${state.label} ${head}` : `⌥ ${head}`];
   const dirty = Math.max(0, state.dirtyTotal ?? 0);
   if (dirty > 0) parts.push(`*${dirty}`);
   if ((state.ahead ?? 0) > 0) parts.push(`+${state.ahead}`);
@@ -260,6 +263,33 @@ export function gitSegment(
     : strongText(parts.join(' '), tone, opts);
 }
 
+/** The code this TUI process loaded at boot (not the session tree HEAD). */
+export interface RunningBuildState {
+  /** Boot commit (full or short); '' = unknown (rendered as `?`). */
+  sha: string;
+  /** True when the installed/checkout code moved after boot — a relaunch runs the new build.
+   *  null = could not compare (not the same as «not stale»). */
+  stale: boolean | null;
+  /** The commit a relaunch would run, when known. */
+  currentSha?: string;
+}
+
+/** Running-build pill.
+ *
+ *     ▶ 실행 5c0f98f                         — boot build matches current code (overlay)
+ *     ▶ 실행 5c0f98f ⟳ 재기동 필요 → 1a2b3c4  — code moved after boot (yellow, bold)
+ *     ▶ 실행 5c0f98f ?                        — could not compare (overlay)
+ *     ▶ 실행 ?                                — boot build unknown (overlay) */
+export function runningBuildSegment(state: RunningBuildState | null | undefined, opts: StatusBarRenderOptions = {}): string {
+  if (!state) return '';
+  if (!state.sha) return text('▶ 실행 ?', 'overlay', opts);
+  const label = `▶ 실행 ${state.sha.slice(0, 7)}`;
+  if (state.stale === null) return text(`${label} ?`, 'overlay', opts);
+  if (!state.stale) return text(label, 'overlay', opts);
+  const target = state.currentSha ? ` → ${state.currentSha.slice(0, 7)}` : '';
+  return strongText(`${label} ⟳ 재기동 필요${target}`, 'yellow', opts);
+}
+
 /** Truncate a model id at the first parameter-size marker (e.g.
  *  `qwen3.6-35b-a3b-ud-mlx` → `qwen3.6-35b`). The marker pattern
  *  matches one or more digits followed by `b`/`B` (e.g. `7b`, `35b`,
@@ -289,7 +319,7 @@ function truncateAtParamSize(model: string): string {
  *   - `local:qwen3.6-35b-a3b-ud-mlx` → `local:qwen3.6-35b`
  *   - `node-b:qwen2.5-72b-instruct`    → `node-b:qwen2.5-72b`
  *   - `claude-opus-4-6`              → unchanged (no `\d+b` marker) */
-export function modelSegment(info: ActiveProviderInfo, opts: StatusBarRenderOptions = {}): string {
+export function modelSegment(info: Pick<ActiveProviderInfo, 'provider' | 'model'>, opts: StatusBarRenderOptions = {}): string {
   if (!info.model || info.model === '(none)') {
     return strongText(info.provider, 'pink', opts);
   }

package/src/status/status-provider-info.ts

@@ -0,0 +1,58 @@
+// ── Status-line provider/model reader ──
+//
+// 하단 상태줄은 키 입력마다 다시 그린다. 종전엔 그때마다 `inspectActiveProvider()` 를 불러
+//   ① `getUserConfig()` 의 stat ② `decideProviderForConfig()` 의 자격 확인 ③ 상태줄이 «안 쓰는»
+//   `authDetail`(codex 면 auth 스토어 readFileSync + JSON.parse) 을 매 렌더 동기로 했다.
+//   📏 실측(10-14 mbp · 운영 HOME · 500회 평균): 렌더 1회 98µs.
+// ⇒ 상태줄이 쓰는 것은 provider·model 둘뿐이라, 그 둘만 짧게 기억한다.
+//   ⛔ 기억이 «낡은 값»으로 굳지 않게: runtimeModel 이 바뀌면 즉시, 설정 파일이 바뀌면 TTL(2s) 안에 다시 읽고,
+//   그렇지 않아도 `maxAgeMs` 마다 다시 판정한다(auto 공급자는 자격 유무로 갈리므로). 표시 전용이라 2s 지연은 허용.
+
+import { inspectActiveProvider, type ActiveProviderInfo } from '../provider-summary.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+
+export type StatusProviderInfo = Pick<ActiveProviderInfo, 'provider' | 'model'>;
+
+export interface StatusProviderInfoReaderDeps {
+  readConfig?: () => UserConfig;
+  inspect?: (cfg: UserConfig, runtimeModel?: string) => StatusProviderInfo;
+  now?: () => number;
+  /** 이 안에서는 설정도 다시 안 읽는다(렌더 경로 0 I/O). */
+  ttlMs?: number;
+  /** 설정이 그대로여도 이만큼 지나면 다시 판정한다. */
+  maxAgeMs?: number;
+}
+
+export function createStatusProviderInfoReader(
+  deps: StatusProviderInfoReaderDeps = {},
+): (runtimeModel?: string) => StatusProviderInfo {
+  const readConfig = deps.readConfig ?? (() => getUserConfig());
+  const inspect = deps.inspect ?? ((cfg, runtimeModel) => inspectActiveProvider(cfg, runtimeModel));
+  const now = deps.now ?? Date.now;
+  const ttlMs = deps.ttlMs ?? 2_000;
+  const maxAgeMs = deps.maxAgeMs ?? 30_000;
+  let memo: {
+    info: StatusProviderInfo;
+    cfg: UserConfig;
+    runtimeModel: string | undefined;
+    checkedAt: number;
+    inspectedAt: number;
+  } | null = null;
+
+  return (runtimeModel?: string): StatusProviderInfo => {
+    const t = now();
+    // ⛔ 조기 반환에도 최대 수명을 건다 — TTL 만 보면 «29초에 설정 확인 → 30.001초 렌더»가 재판정 없이 지나간다.
+    const fresh = memo !== null && t - memo.inspectedAt < maxAgeMs;
+    if (memo && fresh && memo.runtimeModel === runtimeModel && t - memo.checkedAt < ttlMs) return memo.info;
+    // getUserConfig() 는 파일 mtime 이 같으면 «같은 객체»를, 바뀌면 새 객체를 돌려준다(user-config.ts getUserConfig).
+    const cfg = readConfig();
+    if (memo && fresh && memo.cfg === cfg && memo.runtimeModel === runtimeModel) {
+      memo.checkedAt = t;
+      return memo.info;
+    }
+    const full = inspect(cfg, runtimeModel);
+    const info: StatusProviderInfo = { provider: full.provider, model: full.model };
+    memo = { info, cfg, runtimeModel, checkedAt: t, inspectedAt: t };
+    return info;
+  };
+}

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

@@ -89,6 +89,8 @@ export interface RejudgeDeps {
   requestRepair?: (request: RepairLaunchRequest) => Promise<void>;
   applyRepair?: (request: RepairCasRequest) => RepairCasOutcome;
   notifyRepair?: (seat: string, body: string) => void;
+  /** Shared new-launch budget for this `tasks rejudge --all` call. */
+  repairBudget?: import('./repair-cycle.js').RepairTickBudget;
   /** 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;
@@ -533,7 +535,8 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
         mustFix: mustFix ?? [], liveMoves: deps.liveMoves, now: now(), readFile: read,
         ...(deps.requestRepair ? { request: deps.requestRepair } : {}),
         ...(deps.applyRepair ? { apply: deps.applyRepair } : {}),
-        ...(deps.notifyRepair ? { notify: deps.notifyRepair } : {}) });
+        ...(deps.notifyRepair ? { notify: deps.notifyRepair } : {}),
+        ...(deps.repairBudget ? { repairBudget: deps.repairBudget } : {}) });
       step('repair', result.decision, result.reason, true);
       return outcomes;
     }

package/src/task-agent/remote-rejudge-bind.ts

@@ -3,9 +3,23 @@ import { dirname } from 'node:path';
 import { debug } from '../debug/log.js';
 import { loadRunLedger } from '../self-implement/run-ledger.js';
 import { bindCardEvidence, podChildRunIds, readCardRunSnapshot, refreshCardRunBinding } from './card-evidence.js';
-import { remoteLedgerMirrorDir } from './parent-host.js';
+import { mirrorRemoteRunLedgers, remoteLedgerMirrorDir } from './parent-host.js';
 import { cardPrNumber, type TaskCard } from './task-hand.js';
 
+const RECENT_LAUNCH_MS = 24 * 60 * 60 * 1000;
+
+type BindDeps = {
+  now?: () => number;
+  mirror?: typeof mirrorRemoteRunLedgers;
+  onFailure?: (failure: { card: string; runId: string; host: string; reason: string }) => void;
+};
+
+function recentlyLaunched(card: TaskCard, now: number): boolean {
+  const launch = [...card.history].reverse().find(event => event.event === 'launch');
+  const at = Date.parse(launch?.at ?? card.createdAt);
+  return Number.isFinite(at) && at <= now && now - at < RECENT_LAUNCH_MS;
+}
+
 /**
  * A remote child PR can appear after the last HQ card refresh. A card without a PR is otherwise absent from
  * `rejudgeCandidates`, so the normal rejudge tick never reaches `mirrorRemoteCardLedger` or the binding replay.
@@ -14,8 +28,16 @@ import { cardPrNumber, type TaskCard } from './task-hand.js';
  */
 export async function bindMirroredRemoteRejudgeCards(
   tasks: Readonly<Record<string, TaskCard>>, statePath: string,
+  deps: BindDeps = {},
 ): Promise<{ scanned: number; bound: number; skipped: number }> {
   const root = dirname(statePath);
+  const now = (deps.now ?? Date.now)();
+  const mirror = deps.mirror ?? mirrorRemoteRunLedgers;
+  const reportFailure = (card: TaskCard, reason: string): void => {
+    const failure = { card: card.id, runId: card.runId!, host: card.parentHost!.host, reason: reason.slice(0, 300) };
+    try { (deps.onFailure ?? ((data) => debug.log('task-agent', 'remote-rejudge-bind-failed', data)))(failure); }
+    catch { /* observation must not stop the other cards */ }
+  };
   let scanned = 0;
   let bound = 0;
   let skipped = 0;
@@ -25,6 +47,10 @@ export async function bindMirroredRemoteRejudgeCards(
     scanned++;
     const dir = remoteLedgerMirrorDir(root, card.parentHost.host);
     try {
+      // This prepass runs before PR-based candidate selection. Pulling here breaks the otherwise circular
+      // dependency: cards with a remote PR cannot be selected while their parent/child ledgers are absent locally.
+      // Limit fresh remote pulls to recent launches, but keep binding older ledgers already mirrored at HQ.
+      if (recentlyLaunched(card, now)) mirror(card.parentHost, card.runId, root);
       const snapshot = await readCardRunSnapshot(card, {
         loadLedger: (id) => loadRunLedger(id, dir),
         podFinishes: () => [],
@@ -34,9 +60,14 @@ export async function bindMirroredRemoteRejudgeCards(
       const childRunId = evidence.childRunId;
       const pr = evidence.pr;
       const child = childRunId ? snapshot.children[childRunId] : null;
+      if (snapshot.readErrors?.length) {
+        reportFailure(card, snapshot.readErrors.join('; '));
+        skipped++;
+        continue;
+      }
       // A PR event alone is not a completed remote run. The rejudge candidate must have the same exact
       // child PR and terminal status that remoteBoundRunTerminal will later require.
-      if (snapshot.readErrors?.length || !parent || !childRunId || !pr?.url || !child
+      if (!parent || !childRunId || !pr?.url || !child
         || !podChildRunIds(parent, card.runId).includes(childRunId)
         || !child.some((entry) => entry.event === 'pr-opened' && entry.data?.number === pr.number
           && entry.data?.url === pr.url)
@@ -53,9 +84,7 @@ export async function bindMirroredRemoteRejudgeCards(
       else skipped++;
     } catch (error) {
       skipped++;
-      try { debug.log('task-agent', 'remote-rejudge-bind-failed', {
-        card: card.id, runId: card.runId, host: card.parentHost.host, reason: error instanceof Error ? error.message : String(error),
-      }); } catch { /* observation must not stop the other cards */ }
+      reportFailure(card, error instanceof Error ? error.message : String(error));
     }
   }
   return { scanned, bound, skipped };

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

@@ -2,6 +2,7 @@
 import { spawn } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
 import { mintRunId } from '../harness/harness-space.js';
 import { spawnElanousSync } from '../instance/spawn-elanous.js';
 import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
@@ -29,8 +30,12 @@ export interface RepairCycleInput {
   notify?: (seat: string, body: string) => void;
   observeLaunch?: (move: string, runId: string) => void;
   resolveOwner?: (card: TaskCard) => RepairOwner;
+  /** Shared only by one `tasks rejudge --all` invocation; a single-card rejudge has no cap. */
+  repairBudget?: RepairTickBudget;
 }
 
+export interface RepairTickBudget { max: number; requested: number; capped: number }
+
 export type RepairCycleOutcome = { decision: 'would-repair' | 'repair-requested' | 'repair-pending' | 'repair-applied' | 'repair-failed' | 'repair-stopped'; reason: string };
 export type RepairOwner = { seat?: TaskSeat; source: string; reason?: string };
 
@@ -230,6 +235,13 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       ? { ...current, status: 'failed', history: [...(current.history ?? []), { at: now.toISOString(), event: 'repair-owner-missing', pr, head, detail: reason }] } : undefined);
     return { decision: 'repair-stopped', reason };
   }
+  if (input.repairBudget && input.repairBudget.requested >= input.repairBudget.max) {
+    input.repairBudget.capped++;
+    const reason = `repairMaxPerTick 상한 ${input.repairBudget.max} · 다음 틱에 재판정`;
+    try { debug.log('task-agent', 'repair-tick-cap', { card: card.id, pr, head, max: input.repairBudget.max,
+      requested: input.repairBudget.requested, capped: input.repairBudget.capped, move: judged.judgement.move }); } catch { /* fail-soft */ }
+    return { decision: 'would-repair', reason };
+  }
   const next = attempts.length + 1;
   const runId = mintRunId();
   const { from, to } = alternateRepairModel(card);
@@ -251,6 +263,7 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
   try {
     await (input.request ?? defaultRequestRepair)({ card: card.id, pr, head, repo, resultPath, goalFile,
       runId, model: to, seat: owner.seat });
+    if (input.repairBudget) input.repairBudget.requested++;
   } catch (error) {
     const reason = `repair launch failed: ${error instanceof Error ? error.message : String(error)}`;
     updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === runId && entry.status === 'requested')

package/src/task-orchestrator/surfaces/kubectl-transient-retry.ts

@@ -0,0 +1,51 @@
+/**
+ * K3S-SECRET-DB-LOCK-RETRY — kubectl 호출이 «일시 오류»로 거부되면 지수 백오프로 다시 친다.
+ *
+ * 근거: node-b k3d(k3s · sqlite 저장소)가 Pod Secret 생성 때
+ *   `Error from server: error when creating "STDIN": rpc error: code = Unknown desc = database is locked`
+ * 로 거부했다(10-15 02:11 KST 전후 4건 · TC #4186). sqlite 쓰기 잠금 경합이라 잠시 뒤 같은 apply 는 선다.
+ *
+ * ⛔ 판정 문구는 «실측 근거가 있는 것»만 둔다 — 짐작으로 늘리면 진짜 거부(권한·스키마)를 백오프 동안 삼킨다.
+ * 재시도 소진 시에만 호출부의 기존 실패 경로로 마지막 결과를 그대로 돌려준다.
+ */
+import { debug } from '../../debug/log.js';
+
+export type KubectlCallResult = { status: number | null; stdout: string; stderr: string };
+
+/** 실측된 일시 오류 문구(stderr 만 · 부분 일치 · 대소문자 무시 — stdout 은 apply 결과라 판정에 안 쓴다). */
+export const KUBECTL_TRANSIENT_PATTERNS: readonly RegExp[] = [/database is locked/i];
+
+/** 재시도 사이 대기(ms) — 길이가 곧 재시도 상한(4회 · 합 7.5s). */
+export const KUBECTL_TRANSIENT_BACKOFF_MS: readonly number[] = [500, 1_000, 2_000, 4_000];
+
+export function kubectlTransientReason(result: KubectlCallResult): string | null {
+  if (result.status === 0) return null;
+  const hit = KUBECTL_TRANSIENT_PATTERNS.find((pattern) => pattern.test(result.stderr));
+  return hit ? hit.source : null;
+}
+
+/**
+ * 첫 결과 `first` 가 일시 오류일 때만 부른다(성공 경로에 await 를 더하지 않으려고 — 호출부의 마이크로태스크 순서를 지킨다).
+ * 다시 친 결과가 성공이거나 일시 오류가 아니면 즉시 돌려주고, 백오프를 다 써도 일시 오류면 마지막 결과를 돌려준다.
+ */
+export async function retryKubectlTransient(
+  run: () => KubectlCallResult,
+  first: KubectlCallResult,
+  opts: { sleep: (ms: number) => Promise<void>; category: string; data?: Record<string, unknown>; backoffMs?: readonly number[] },
+): Promise<KubectlCallResult> {
+  const backoff = opts.backoffMs ?? KUBECTL_TRANSIENT_BACKOFF_MS;
+  let last = first;
+  let reason = kubectlTransientReason(last);
+  for (let i = 0; i < backoff.length && reason; i++) {
+    debug.log(opts.category, 'retry', { ...opts.data, attempt: i + 1, maxAttempts: backoff.length, delayMs: backoff[i], reason });
+    await opts.sleep(backoff[i]!);
+    last = run();
+    reason = kubectlTransientReason(last);
+    if (last.status === 0) {
+      debug.log(opts.category, 'retry-recovered', { ...opts.data, attempt: i + 1 });
+      return last;
+    }
+  }
+  if (reason) debug.log(opts.category, 'retry-exhausted', { ...opts.data, attempts: backoff.length, reason, stderr: last.stderr.trim().slice(0, 300) }, { level: 'warn' });
+  return last;
+}