elanous 0.2.40 → 0.2.42

package/src/agent-mission/tool-install.ts

@@ -1,11 +1,13 @@
 import { spawnSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { delimiter, isAbsolute, join, resolve } from 'node:path';
 import { detectDistroFamily, toolInstallLine, type DistroFamily } from '../cli/doctor-distro.js';
 import { debug } from '../debug/log.js';
 import { emitDecision, type DecisionEvent } from '../live/detail-switch.js';
+import { checkClaudeSubscription } from './claude-subscription.js';
+import { claudeBackend, codexBackend, resolveBackendSpawn } from './driver.js';
 
 type RemedyTool = 'gh' | 'rg' | 'node' | 'codex' | 'jq' | 'ffmpeg';
 export type SmokeTool = RemedyTool | 'git';
@@ -26,6 +28,90 @@ export interface SmokeDeps {
   exec?: (cmd: string[], opts: { stdin?: string; timeoutMs: number }) => ExecResult;
 }
 
+export type AgentCli = 'claude' | 'codex';
+export type AgentCliDetection = {
+  agent: AgentCli;
+  /** null means the executable/version probe could not establish installation state. */
+  installed: boolean | null;
+  executable: 'present' | 'missing' | 'unknown';
+  login: 'ready' | 'needed' | 'api-key' | 'unknown';
+  message: string;
+};
+
+type AgentCliRunner = (command: string, args: string[], options: {
+  encoding: 'utf8'; timeout: number; env: Record<string, string>;
+}) => ReturnType<typeof spawnSync>;
+
+function verifiedAgentVersion(agent: AgentCli, raw: string): boolean {
+  const prefix = agent === 'claude' ? /^(?:Claude(?: Code)?\s+)?v?/i : /^(?:Codex(?:-CLI)?\s+)?v?/i;
+  const versioned = raw.replace(prefix, '');
+  // Probe output is untrusted: validate its shape but never return any part of it.
+  return /^\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?(?: \(Claude Code\))?$/i.test(versioned);
+}
+
+function agentExecutableExists(command: string, env: Record<string, string>): boolean {
+  if (command.includes('/')) return existsSync(isAbsolute(command) ? command : resolve(command));
+  return (env.PATH ?? '').split(delimiter).some((directory) => existsSync(join(directory || process.cwd(), command)));
+}
+
+/** Inspect the local agent CLI without returning auth output or credential values. */
+export function detectAgentCli(
+  agent: AgentCli,
+  options: { env?: Record<string, string | undefined>; runCli?: AgentCliRunner } = {},
+): AgentCliDetection {
+  const backend = agent === 'claude' ? claudeBackend : codexBackend;
+  const spawn = resolveBackendSpawn(backend, options.env ?? process.env);
+  const runCli = options.runCli ?? spawnSync;
+  const run = (args: string[]) => runCli(agent, args, {
+    encoding: 'utf8', timeout: 5_000, env: spawn.env,
+  });
+  let versionResult: ReturnType<typeof spawnSync>;
+  try { versionResult = run(['--version']); }
+  catch (error) {
+    if ((error as { code?: string })?.code === 'ENOENT') {
+      const present = agentExecutableExists(spawn.cmd, spawn.env);
+      return { agent, installed: present ? null : false, executable: present ? 'unknown' : 'missing', login: 'unknown', message: present ? `${agent}: 실행 파일을 실행할 수 없어 상태 확인 불가` : `${agent}: 설치되지 않음` };
+    }
+    return { agent, installed: null, executable: 'unknown', login: 'unknown', message: `${agent}: 설치 여부 확인 불가` };
+  }
+  if ((versionResult.error as NodeJS.ErrnoException | undefined)?.code === 'ENOENT') {
+    const present = agentExecutableExists(spawn.cmd, spawn.env);
+    return { agent, installed: present ? null : false, executable: present ? 'unknown' : 'missing', login: 'unknown', message: present ? `${agent}: 실행 파일을 실행할 수 없어 상태 확인 불가` : `${agent}: 설치되지 않음` };
+  }
+  const rawVersion = `${versionResult.stdout ?? ''}\n${versionResult.stderr ?? ''}`.trim().split(/\r?\n/, 1)[0] ?? '';
+  const versionVerified = versionResult.status === 0 && verifiedAgentVersion(agent, rawVersion);
+  if (!versionVerified) {
+    const executable = versionResult.status === null || versionResult.error ? 'unknown' : 'present';
+    return {
+      agent, installed: null, executable, login: 'unknown',
+      message: executable === 'present' ? `${agent}: 실행 파일 있음, 버전 확인 불가` : `${agent}: 설치 여부 확인 불가`,
+    };
+  }
+
+  let login: AgentCliDetection['login'] = 'unknown';
+  if (agent === 'claude') {
+    const auth = checkClaudeSubscription({ env: spawn.env, runCli });
+    login = auth.ok ? 'ready' : auth.reason === 'logged-out' || auth.reason === 'api-key' ? 'needed' : 'unknown';
+  } else {
+    try {
+      const auth = run(['login', 'status']);
+      const output = `${auth.stdout ?? ''}\n${auth.stderr ?? ''}`;
+      const normalized = output.trim();
+      if (auth.status === 0 && /^logged in using an api key\.?$/i.test(normalized)) login = 'api-key';
+      else if (auth.status === 0 && /^logged in(?: using (?:chatgpt|openai))?\.?$/i.test(normalized)) login = 'ready';
+      else if (/\bnot\b.*\blogged in\b|\blogged out\b|\blogout\b|\bplease log in\b|\brun codex login\b/i.test(normalized)) login = 'needed';
+    } catch { /* Keep authentication unknown when the probe itself fails. */ }
+  }
+  const message = login === 'ready'
+    ? `${agent}: 설치됨, 로그인 확인됨`
+    : login === 'api-key'
+      ? `${agent}: API 키 로그인됨 (구독 로그인 아님)`
+    : login === 'needed'
+      ? `${agent}: 설치됨, 로그인 필요`
+      : `${agent}: 설치됨, 로그인 상태 확인 불가`;
+  return { agent, installed: true, executable: 'present', login, message };
+}
+
 function defaultExec(cmd: string[], opts: { stdin?: string; timeoutMs: number }): ExecResult {
   const result = spawnSync(cmd[0]!, cmd.slice(1), {
     input: opts.stdin, timeout: opts.timeoutMs, encoding: 'utf8',

package/src/agent-substrate/context-strategy.ts

@@ -39,9 +39,9 @@ export interface CompactionOutcome {
  *  선택 필드로 읽는다. 미설정(구 config·테스트)이면 기본 1(첫 앵커 pin). 0=비활성. */
 interface AutoCompactCfgWithAnchor { preserveFirstN?: number }
 
-/** context 전략 계약 — loop 이 매 턴(turn>0) 호출. 기본=2-tier compaction. 주입으로 교체(read-time projection 등). */
+/** context 전략 계약 — loop 이 mid-loop(turn>0) 호출. 기본=2-tier compaction. 주입으로 교체(read-time projection 등). */
 export interface ContextStrategy {
-  compact(messages: LLMMessage[], ctx: { model: string; sessionId?: string; config: unknown }): Promise<CompactionOutcome>;
+  compact(messages: LLMMessage[], ctx: { model: string; sessionId?: string; config: unknown; observedInputTokens?: number }): Promise<CompactionOutcome>;
 }
 
 /**
@@ -54,8 +54,8 @@ export function createDefaultContextStrategy(): ContextStrategy {
     async compact(messages, ctx): Promise<CompactionOutcome> {
       const { shouldAutoCompact } = require('../compact/auto.js') as typeof import('../compact/auto.js');
       const acCfg = ctx.config as Parameters<typeof shouldAutoCompact>[2];
-      const decision = shouldAutoCompact(messages, ctx.model, acCfg);
-      const beforeTokens = decision.usedTokens; // estimateMessagesTokens(messages) 동일 계측
+      const decision = shouldAutoCompact(messages, ctx.model, acCfg, ctx.observedInputTokens);
+      const beforeTokens = estimateMessagesTokens(messages);
       if (!decision.fire) {
         return { fired: false, messages, reduced: false, escalated: false, ratio: decision.ratio, usedTokens: decision.usedTokens, beforeTokens, afterTokens: beforeTokens };
       }

package/src/agent-substrate/self-review-cli.ts

@@ -20,13 +20,13 @@ import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { tierModel } from '../llm/model-defaults.js';
 import { buildReviewObservation, reviewIntentFingerprint, safeLogText } from './review-observation.js';
-import { checkCitedReviewPathsAtHead, citedReviewPaths } from './review-finding-key.js';
+import { checkCitedReviewPathsAtHead, citedReviewPaths, reviewFindingKey } from './review-finding-key.js';
 import { DEFAULT_REVIEW_BACKEND, defaultAcpReviewTimeoutSec } from './acp-reviewer.js';
 import { ZAI_OPENROUTER_FALLBACK_MODEL } from '../llm/zai-coding-plan.js';
 import { debug } from '../debug/log.js';
 import { ACP_BACKENDS, canonicalizeBackendId } from '../acp/backend-registry.js';
 import { buildManualReviewIntent, intentFromPr, prIntentSectionCoverage, reviewIntentTruncationFromPr, reviewIntentTruncationObservation } from './review-intent.js';
-import { budgetReviewerContext, isNoneSentinelFinding, reviewDiffBudgetObservation, splitDiffByFile, type ReviewImage, type ReviewInput, type ReviewerContextItem, type ReviewResult } from './pr-reviewer.js';
+import { NO_VERDICT_LINE_REASON, budgetReviewerContext, isNoneSentinelFinding, reviewDiffBudgetObservation, splitDiffByFile, type ReviewImage, type ReviewInput, type ReviewerContextItem, type ReviewResult } from './pr-reviewer.js';
 import type { ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { getUserConfig, type LLMProviderName, type ReviewerMixSpec, type RoleLlmSpec, type SubscriptionReviewerSpec } from '../user-config.js';
 import { loadLlmPolicy } from '../policy/llm-policy.js';
@@ -96,6 +96,8 @@ export interface SelfReviewCliOpts {
   save?: string | undefined;
   /** Review only commits after a previously saved PR review head. */
   sinceReview?: string | undefined;
+  /** Internal delta self-heal metadata; never parsed from user CLI arguments. */
+  deltaHeal?: { cause: string; prescription: string } | undefined;
   /** One invocation past r5, only for a PR in OP's traffic.json allowlist; the reason is recorded before review starts. */
   overCapReason?: string | undefined;
 }
@@ -177,16 +179,97 @@ export interface SelfReviewCliOutcome {
 
 interface SavedReviewEvidence {
   heads: string[];
-  records: Array<{ head: string; reviewedAt: number }>;
+  records: Array<{ head: string; reviewedAt: number; model?: string }>;
+  loopRounds: Array<{ head: string; reviewedAt: number; state: 'clear' | 'stale-reopen' }>;
+  fixedFindings: string[];
+  priorFindings: string[];
   unreadableFiles: string[];
 }
 
+export interface ReviewLoopBreakerAssessment {
+  state: 'clear' | 'stale-reopen';
+  staleFindings: Array<{ finding: string; reason: 'fixed-finding-reopened' | 'author-test-evidence' }>;
+}
+
+export function assessReviewLoopBreaker(input: {
+  priorFindings: string[];
+  previouslyFixedFindings?: string[];
+  deltaFindings: Array<{ finding: string; status: 'fixed' | 'open' }>;
+  currentFindings: string[];
+  changedFiles: string[];
+}): ReviewLoopBreakerAssessment {
+  const changedTestFiles = new Set(input.changedFiles.filter((file) => /\.test\.[cm]?[jt]sx?$/i.test(file)));
+  const staleFindings: ReviewLoopBreakerAssessment['staleFindings'] = [];
+  const add = (finding: string, reason: ReviewLoopBreakerAssessment['staleFindings'][number]['reason']) => {
+    if (!staleFindings.some((entry) => reviewFindingKey(entry.finding).key === reviewFindingKey(finding).key)) staleFindings.push({ finding, reason });
+  };
+  for (const fixed of input.deltaFindings.filter((entry) => entry.status === 'fixed')) {
+    if (input.currentFindings.some((current) => reviewFindingKey(current).key === reviewFindingKey(fixed.finding).key)) {
+      add(fixed.finding, 'fixed-finding-reopened');
+    }
+  }
+  for (const fixed of input.previouslyFixedFindings ?? []) {
+    if (input.currentFindings.some((current) => reviewFindingKey(current).key === reviewFindingKey(fixed).key)) {
+      add(fixed, 'fixed-finding-reopened');
+    }
+  }
+  for (const prior of input.priorFindings) {
+    const priorPaths = new Set(citedReviewPaths(prior));
+    for (const current of input.currentFindings) {
+      const sameFinding = reviewFindingKey(prior).key === reviewFindingKey(current).key
+        || citedReviewPaths(current).some((path) => priorPaths.has(path));
+      if (!sameFinding) continue;
+      const citedChangedTest = [...changedTestFiles].some((file) => {
+        const escapedFile = file.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return new RegExp('(?:^|[\\s`])' + escapedFile + ':\\d+(?::\\d+)?(?:\\b|[`),.;])').test(current);
+      });
+      if (citedChangedTest) add(current, 'author-test-evidence');
+    }
+  }
+  return { state: staleFindings.length ? 'stale-reopen' : 'clear', staleFindings };
+}
+
+function trailingStaleReopenRounds(rounds: SavedReviewEvidence['loopRounds']): number {
+  let count = 0;
+  for (const round of [...rounds].sort((a, b) => a.reviewedAt - b.reviewedAt).reverse()) {
+    if (round.state !== 'stale-reopen') break;
+    count++;
+  }
+  return count;
+}
+
+function savedFindingList(value: unknown): string[] {
+  const values = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
+  return values.filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0);
+}
+
+function reviewLoopBreakerLockPath(pr: string, root = effectiveInstanceRoot()): string {
+  return join(root, 'review-results', `review-loop-breaker-${pr}.json`);
+}
+
+function readReviewLoopBreakerLock(pr: string, root = effectiveInstanceRoot()): Record<string, unknown> | undefined {
+  try {
+    const value: unknown = JSON.parse(readFileSync(reviewLoopBreakerLockPath(pr, root), 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+    const record = value as Record<string, unknown>;
+    return record.pr === pr && typeof record.head === 'string' && COMMIT_OID.test(record.head)
+      && record.state === 'waiver-needed' ? record : undefined;
+  } catch { return undefined; }
+}
+
+function writeReviewLoopBreakerLock(pr: string, head: string, reason: string, root = effectiveInstanceRoot()): void {
+  const path = reviewLoopBreakerLockPath(pr, root);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify({ pr, head, state: 'waiver-needed', reason, writtenAt: Date.now() }) + '\n');
+}
+
 interface SavedReviewForDelta {
   file: string;
   headCommit: string;
   mustFix: string[];
   reviewInputChars: number;
   reviewDurationMs: number;
+  result: Record<string, unknown>;
 }
 
 function selectSavedReviewForDelta(pr: string, selector: string, root = effectiveInstanceRoot()):
@@ -206,17 +289,20 @@ function selectSavedReviewForDelta(pr: string, selector: string, root = effectiv
     const row = raw as Record<string, unknown>;
     const recordPr = typeof row.pr === 'string' ? row.pr
       : Number.isSafeInteger(row.pr) ? String(row.pr) : undefined;
-    if (recordPr !== pr || row.reviewed !== true || typeof row.headCommit !== 'string' || !COMMIT_OID.test(row.headCommit)) continue;
+    if (recordPr !== pr || row.reviewed !== true || !['pass', 'warn', 'fail'].includes(String(row.verdict))
+      || typeof row.headCommit !== 'string' || !COMMIT_OID.test(row.headCommit)) continue;
     const named = name === token || name === `${token}.json` || name.startsWith(`${token}-${pr}-`);
     const byHead = /^[a-f0-9]{7,64}$/i.test(token) && row.headCommit.toLowerCase().startsWith(token.toLowerCase());
     if (!named && !byHead) continue;
-    if (!Array.isArray(row.mustFix) || !row.mustFix.every((item) => typeof item === 'string')) continue;
+    if (!Array.isArray(row.mustFix)) continue;
+    const mustFix = row.mustFix.filter((item): item is string => typeof item === 'string');
+    if (mustFix.length !== row.mustFix.length) continue;
     if (typeof row.reviewInputChars !== 'number' || !Number.isFinite(row.reviewInputChars) || row.reviewInputChars <= 0
       || typeof row.reviewDurationMs !== 'number' || !Number.isFinite(row.reviewDurationMs) || row.reviewDurationMs <= 0) continue;
     let mtimeMs = 0;
     try { mtimeMs = statSync(join(dir, name)).mtimeMs; } catch { continue; }
-    records.push({ file: name, headCommit: row.headCommit.toLowerCase(), mustFix: row.mustFix as string[],
-      reviewInputChars: row.reviewInputChars, reviewDurationMs: row.reviewDurationMs, mtimeMs });
+    records.push({ file: name, headCommit: row.headCommit.toLowerCase(), mustFix,
+      reviewInputChars: row.reviewInputChars, reviewDurationMs: row.reviewDurationMs, result: row, mtimeMs });
   }
   const distinctHeads = [...new Set(records.map((record) => record.headCommit))];
   if (distinctHeads.length > 1) return { error: 'saved-review-selector-ambiguous' };
@@ -298,10 +384,13 @@ function savedReviewEvidence(
 ): SavedReviewEvidence {
   const dir = join(root, 'review-results');
   let names: string[];
-  try { names = readdirSync(dir); } catch { return { heads: [], records: [], unreadableFiles: [] }; }
+  try { names = readdirSync(dir); } catch { return { heads: [], records: [], loopRounds: [], fixedFindings: [], priorFindings: [], unreadableFiles: [] }; }
   const escapedPr = pr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const matchingPrInName = new RegExp(`(?:^|-)${escapedPr}(?:-|\\.json$)`, 'i');
-  const records = new Map<string, { head: string; reviewedAt: number }>();
+  const records = new Map<string, { head: string; reviewedAt: number; model?: string }>();
+  const loopRounds = new Map<string, { head: string; reviewedAt: number; state: 'clear' | 'stale-reopen' }>();
+  const fixedFindings = new Map<string, string>();
+  let latestFindings: { reviewedAt: number; findings: string[] } | undefined;
   const unreadableFiles: string[] = [];
   for (const name of names) {
     if (!name.toLowerCase().endsWith('.json')) continue;
@@ -332,16 +421,40 @@ function savedReviewEvidence(
       const recordPath = join(dir, name);
       const reviewedAt = typeof result.reviewedAt === 'number' && Number.isFinite(result.reviewedAt)
         ? result.reviewedAt : statSync(recordPath).mtimeMs;
+      const findings = savedFindingList(result.mustFix);
+      if (!latestFindings || reviewedAt > latestFindings.reviewedAt) latestFindings = { reviewedAt, findings };
       const normalized = head.toLowerCase();
+      const model = [result.model, result.respondedModel, result.requestedModel]
+        .find((value): value is string => typeof value === 'string' && value.trim().length > 0);
       const existing = records.get(normalized);
-      if (!existing || reviewedAt > existing.reviewedAt) records.set(normalized, { head: normalized, reviewedAt });
+      if (!existing || reviewedAt > existing.reviewedAt) records.set(normalized, { head: normalized, reviewedAt, ...(model ? { model } : {}) });
+      const loopBreaker = result.loopBreaker;
+      if (loopBreaker && typeof loopBreaker === 'object' && !Array.isArray(loopBreaker)) {
+        const loopRecord = loopBreaker as Record<string, unknown>;
+        const state = loopRecord.state;
+        if (Array.isArray(loopRecord.fixedFindings)) for (const finding of loopRecord.fixedFindings) {
+          if (typeof finding === 'string' && finding.trim()) fixedFindings.set(reviewFindingKey(finding).key, finding);
+        }
+        if (state === 'clear' || state === 'stale-reopen') {
+          const prior = loopRounds.get(normalized);
+          if (!prior || reviewedAt > prior.reviewedAt) loopRounds.set(normalized, { head: normalized, reviewedAt, state });
+        }
+      }
+      if (Array.isArray(result.deltaFindings)) for (const entry of result.deltaFindings) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+        const delta = entry as Record<string, unknown>;
+        if (delta.status === 'fixed' && typeof delta.finding === 'string' && delta.finding.trim()) {
+          fixedFindings.set(reviewFindingKey(delta.finding).key, delta.finding);
+        }
+      }
     } catch {
       // A filename can associate an unreadable record with this PR; fail closed at the cap.
       if (nameSuggestsPr) { unreadableFiles.push(name); onUnreadable?.(name); }
     }
   }
   const saved = [...records.values()];
-  return { heads: saved.map(({ head }) => head), records: saved, unreadableFiles };
+  return { heads: saved.map(({ head }) => head), records: saved, loopRounds: [...loopRounds.values()],
+    fixedFindings: [...fixedFindings.values()], priorFindings: latestFindings?.findings ?? [], unreadableFiles };
 }
 
 export function savedReviewHeads(pr: string, root = effectiveInstanceRoot()): string[] {
@@ -1974,44 +2087,84 @@ async function runSelfReviewCliCommandPinned(
     const shouldPersistCapResult = previousRoundCount >= 5 && !opts.reviewerMixPrimaryLane;
     const reason = opts.overCapReason?.trim();
     const authorization = previousRoundCount >= 5 ? readCapOverride(pr) : undefined;
+    const capPreflightHead = previousRoundCount >= 5 ? prHeadCommit(pr, deps).value.toLowerCase() : undefined;
     deps.observeDoctorReview?.('round-counted', { pr, previousRoundCount, round: previousRoundCount + 1 });
     const opAllowed = previousRoundCount >= 5 && opAllowsReviewOverCap(pr);
     if (previousRoundCount >= 5) {
       deps.observeDoctorReview?.('cap-attempt', { pr, previousRoundCount, round: previousRoundCount + 1, reasonProvided: Boolean(reason), opAllowed }, { level: 'warn' });
     }
     if (previousRoundCount >= 5 && (!opAllowed || (!authorization && !reason && !opts.reviewerMixCapClaimed))) {
-      const refusalHead = prHeadCommit(pr, deps).value;
+      const refusalHead = capPreflightHead ?? prHeadCommit(pr, deps).value;
+      if (COMMIT_OID.test(refusalHead)) writeReviewLoopBreakerLock(pr, refusalHead, 'review-cap-exceeded');
       const message = !opAllowed
         ? `PR ${pr}: r5 상한 초과 리뷰는 OP traffic.json reviewOverCapAllow 허용 목록에 있어야 합니다.`
         : `PR ${pr}: 저장된 서로 다른 head 리뷰 ${previousRoundCount}개로 r5 상한에 도달했습니다. OP 허용 상태와 --over-cap-reason <사유>가 필요합니다.`;
-      deps.observeDoctorReview?.('cap-refused', { pr, head: refusalHead, previousRoundCount, round: previousRoundCount + 1, reason: opAllowed ? 'missing-reason' : 'not-op-allowlisted' }, { level: 'warn' });
+      deps.observeDoctorReview?.('cap-refused', { pr, head: refusalHead, previousRoundCount, round: previousRoundCount + 1,
+        reason: opAllowed ? 'missing-reason' : 'not-op-allowlisted' }, { level: 'warn' });
+      deps.log('review.loop-breaker', { pr, head: refusalHead, state: 'waiver-needed', reason: 'review-cap-exceeded', previousRoundCount }, { level: 'warn' });
+      if (opts.sinceReview !== undefined) deps.log('review.delta-heal', {
+        pr, cause: 'cap-refused', prescription: 'retain-explicit-refusal', result: 'refused', headCommit: refusalHead,
+      }, { level: 'warn' });
       deps.error(message);
-      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'cap-refused', previousRoundCount, headCommit: refusalHead });
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'waiver-needed', failureReason: 'waiver-needed',
+        loopBreaker: { state: 'waiver-needed', reason: 'review-cap-exceeded' },
+        ...(opts.sinceReview !== undefined ? { verdict: null, deltaOutcome: 'refused', deltaRefusal: 'waiver-needed' } : {}),
+        previousRoundCount, headCommit: refusalHead });
       failed += 1;
       continue;
     }
     let deltaBase: SavedReviewForDelta | undefined;
+    let deltaHeal = opts.deltaHeal;
     if (opts.sinceReview !== undefined) {
       const selected = selectSavedReviewForDelta(pr, opts.sinceReview);
       if ('error' in selected) {
-        const message = `PR ${pr}: --since-review 기준을 읽지 못했습니다 (${selected.error}).`;
-        deps.error(message);
-        if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'delta-base-invalid', deltaRefusal: selected.error });
-        failed += 1;
-        continue;
+        if (selected.error === 'saved-review-directory-missing'
+          || selected.error === 'saved-review-not-found-or-missing-efficiency-receipt') {
+          deltaHeal = { cause: 'no-prior-reviewed-head', prescription: 'full-review-once' };
+        } else {
+          const message = `PR ${pr}: --since-review 기준을 읽지 못했습니다 (${selected.error}).`;
+          deps.error(message);
+          if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, verdict: null,
+            refusal: 'delta-base-invalid', deltaOutcome: 'refused', deltaRefusal: selected.error });
+          failed += 1;
+          continue;
+        }
+      } else {
+        deltaBase = selected.review;
       }
-      deltaBase = selected.review;
     }
     const diffResult = deltaBase ? readDeltaDiffAtHead(pr, deltaBase.headCommit, deps) : { read: readDiffAtHead(pr, deps) };
     if ('error' in diffResult) {
+      if (diffResult.error === 'no-new-head-since-review' && deltaBase) {
+        const reused = { ...deltaBase.result, deltaOutcome: 'reused', deltaHeal: {
+          cause: 'no-new-head', prescription: 'reuse-saved-verdict', result: 'verdict-reused',
+        } };
+        deps.log('review.delta-heal', { pr, cause: 'no-new-head', prescription: 'reuse-saved-verdict',
+          result: 'verdict-reused', headCommit: diffResult.headCommit ?? deltaBase.headCommit }, { level: 'info' });
+        if (opts.json || opts.save !== undefined) results.push(reused);
+        else deps.print(`\n━━ PR ${pr} (${String(deltaBase.result.model ?? 'saved review')}) ━━\n${deps.renderReview(reused as unknown as ReviewResult)}\n판정 재사용: ${deltaBase.headCommit}`);
+        continue;
+      }
       const message = `PR ${pr}: 델타 리뷰를 고정하지 못했습니다 (${diffResult.error}).`;
       deps.error(message);
-      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'delta-base-invalid', deltaRefusal: diffResult.error,
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, verdict: null,
+        refusal: 'delta-base-invalid', deltaOutcome: 'refused', deltaRefusal: diffResult.error,
         ...(diffResult.headCommit ? { headCommit: diffResult.headCommit } : {}) });
       failed += 1;
       continue;
     }
     const diffRead = diffResult.read;
+    const loopLock = readReviewLoopBreakerLock(pr);
+    if (loopLock) {
+      const message = `PR ${pr}: 반복 리뷰 중단 (${String(loopLock.reason ?? 'waiver-needed')}); OP 웨이버가 필요합니다.`;
+      deps.observeDoctorReview?.('loop-breaker', { pr, head: diffRead.headCommit, state: 'waiver-needed', reason: loopLock.reason }, { level: 'warn' });
+      deps.log('review.loop-breaker', { pr, head: diffRead.headCommit, state: 'waiver-needed', reason: loopLock.reason }, { level: 'warn' });
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, verdict: null,
+        refusal: 'waiver-needed', failureReason: 'waiver-needed', loopBreaker: { state: 'waiver-needed', reason: loopLock.reason }, headCommit: diffRead.headCommit });
+      else deps.error(message);
+      failed += 1;
+      continue;
+    }
     const canonicalResultPath = COMMIT_OID.test(diffRead.headCommit)
       ? join(effectiveInstanceRoot(), 'review-results', `pr-${pr}-${diffRead.headCommit.slice(0, 12)}.json`)
       : undefined;
@@ -2043,7 +2196,8 @@ async function runSelfReviewCliCommandPinned(
       failed += 1;
       continue;
     }
-    if (previousRoundCount >= 5 && authorization && diffRead.headCommit.toLowerCase() === authorization.head && !opts.reviewerMixCapClaimed) {
+    if (previousRoundCount >= 5 && authorization && diffRead.headCommit.toLowerCase() === authorization.head
+      && !opts.reviewerMixCapClaimed) {
       const resultExists = canonicalResultPath && existsSync(canonicalResultPath);
       const message = resultExists
         ? `PR ${pr}: 동일 head 리뷰 결과가 이미 저장되어 있습니다: ${canonicalResultPath}`
@@ -2139,7 +2293,8 @@ async function runSelfReviewCliCommandPinned(
       diffRead.diff = delta;
       diffRead.baseCommit = mergeOnlyDeltaRange.base;
     }
-    if (previousRoundCount >= 5 && authorization && !opts.reviewerMixCapClaimed && !claimCapOverride(pr, diffRead.headCommit, authorization.reason, deps.now())) {
+    if (previousRoundCount >= 5 && authorization && !opts.reviewerMixCapClaimed
+      && !claimCapOverride(pr, diffRead.headCommit, authorization.reason, deps.now())) {
       const message = `PR ${pr}: 후속 head 승인 사용 기록을 남기지 못했습니다.`;
       deps.error(message);
       if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'cap-refused', previousRoundCount, headCommit: diffRead.headCommit });
@@ -2494,41 +2649,103 @@ async function runSelfReviewCliCommandPinned(
       claudeFallbackGlm = { reason, model: ZAI_OPENROUTER_FALLBACK_MODEL, glmReviewed: glmFailureReason === undefined,
         ...(glmFailureReason !== undefined ? { glmFailureReason } : {}) };
     }
+    if (deltaBase && review.reviewed !== true && review.failureReason === NO_VERDICT_LINE_REASON) {
+      let retryReview: ReviewResult;
+      try {
+        retryReview = await deps.reviewPullRequest(reviewInput, llmReview ?? prAcpReviewLLM ?? makeApi());
+      } catch (error) {
+        retryReview = { verdict: 'fail', mustFix: [], shouldFix: [], reviewed: false,
+          failureReason: safeLogText(error instanceof Error ? error.message : String(error), 400) };
+      }
+      if (retryReview.reviewed === true) {
+        review = retryReview;
+        deltaHeal = { cause: 'no-verdict-line', prescription: 'retry-delta-once' };
+      } else {
+        const retryResult = safeLogText(retryReview.failureReason === NO_VERDICT_LINE_REASON
+          ? 'no-verdict-line' : `retry-failed-${retryReview.failureReason || 'reviewed-false'}`, 400);
+        deps.log('review.delta-heal', { pr, cause: 'no-verdict-line', prescription: 'retry-delta-once',
+          result: retryResult, headCommit: diffRead.headCommit }, { level: 'warn' });
+        reviewPin?.remove();
+        const fallback = await runSelfReviewCliCommandPinned([pr], {
+          ...opts, sinceReview: undefined,
+          reviewerMixCapClaimed: opts.reviewerMixCapClaimed || Boolean(claimedCapPath),
+          deltaHeal: { cause: 'no-verdict-line', prescription: 'full-review-once-after-delta-retry' },
+        }, deps, pins);
+        results.push(...fallback.results);
+        failed += fallback.failed;
+        releaseCapClaim();
+        continue;
+      }
+    }
     const reviewDurationMs = Math.max(0, deps.now() - startedAt);
     let deltaReceipt: Record<string, unknown> = {};
+    let deltaFindingsForLoop: Array<{ finding: string; status: 'fixed' | 'open' }> = [];
+    // An unreviewed failure has no loop-breaker assessment; do not report a false `clear` round.
+    let loopBreakerOutput: Record<string, unknown> = {};
     if (deltaBase) {
       const assessed = assessDeltaReview(review, deltaBase);
+      const inputRatio = reviewInputChars / deltaBase.reviewInputChars;
+      const timeRatio = reviewDurationMs / deltaBase.reviewDurationMs;
+      const maxRatio = 1 / 3;
       const deltaEfficiency = {
-        inputRatio: reviewInputChars / deltaBase.reviewInputChars,
-        timeRatio: reviewDurationMs / deltaBase.reviewDurationMs,
-        maxRatio: 1 / 3,
+        inputRatio, timeRatio, maxRatio,
+        withinTarget: inputRatio <= maxRatio && timeRatio <= maxRatio,
       };
-      const efficient = deltaEfficiency.inputRatio <= deltaEfficiency.maxRatio
-        && deltaEfficiency.timeRatio <= deltaEfficiency.maxRatio;
       if (review.reviewed !== true) {
         const reason = review.failureReason || 'delta-review-not-completed';
         review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [], failureReason: reason };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency,
-          deltaRefusal: 'delta-review-not-completed' };
+          deltaOutcome: 'refused', deltaRefusal: 'delta-review-not-completed' };
       } else if (!assessed.valid) {
         review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [],
           failureReason: assessed.reason };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency,
-          deltaRefusal: assessed.reason };
-      } else if (!efficient) {
-        review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [],
-          failureReason: 'delta-efficiency-limit-exceeded' };
-        deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
-          deltaFindings: assessed.deltaFindings, deltaInputChars: reviewInputChars,
-          deltaDurationMs: reviewDurationMs, deltaEfficiency, deltaRefusal: 'delta-efficiency-limit-exceeded' };
+          deltaOutcome: 'refused', deltaRefusal: assessed.reason };
       } else {
+        deltaFindingsForLoop = assessed.deltaFindings;
         review = { ...review, reviewed: true, verdict: assessed.mustFix.length ? 'fail' : 'pass',
           mustFix: assessed.mustFix, shouldFix: [] };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaFindings: assessed.deltaFindings, excludedNewFindings: assessed.excludedNewFindings,
-          deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency };
+          deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency, deltaOutcome: 'reviewed' };
+      }
+    }
+    if (review.reviewed === true) {
+      const loopAssessment = assessReviewLoopBreaker({
+        priorFindings: deltaBase?.mustFix ?? savedEvidence.priorFindings,
+        previouslyFixedFindings: savedEvidence.fixedFindings,
+        deltaFindings: deltaFindingsForLoop,
+        currentFindings: review.mustFix,
+        changedFiles: diffFilePaths(diffRead.diff.stdout),
+      });
+      const priorStreak = trailingStaleReopenRounds(savedEvidence.loopRounds);
+      const nextStreak = loopAssessment.state === 'stale-reopen' ? priorStreak + 1 : 0;
+      const fixedFindings = [...new Map([...savedEvidence.fixedFindings,
+        ...deltaFindingsForLoop.filter((entry) => entry.status === 'fixed').map((entry) => entry.finding)]
+      .map((finding) => [reviewFindingKey(finding).key, finding])).values()];
+      let loopState: 'clear' | 'stale-reopen' | 'waiver-needed' = loopAssessment.state;
+      let loopReason: string | undefined;
+      if (nextStreak >= 2) {
+        loopReason = 'two-consecutive-stale-reopen-rounds';
+        writeReviewLoopBreakerLock(pr, diffRead.headCommit, loopReason);
+        review = { ...review, reviewed: false, verdict: 'fail', failureReason: 'waiver-needed' };
+        loopState = 'waiver-needed';
+        if (deltaBase) deltaReceipt = { ...deltaReceipt, deltaOutcome: 'refused', deltaRefusal: 'waiver-needed' };
+      }
+      loopBreakerOutput = { loopBreaker: { state: loopState, fixedFindings,
+        ...(loopReason ? { reason: loopReason } : {}),
+        ...(loopAssessment.staleFindings.length ? { staleFindings: loopAssessment.staleFindings } : {}),
+        staleReopenRounds: nextStreak } };
+      if (loopState !== 'clear' || deltaBase || fixedFindings.length) {
+        deps.observeDoctorReview?.('loop-breaker', { pr, head: diffRead.headCommit, state: loopState,
+          ...(loopReason ? { reason: loopReason } : {}), staleReopenRounds: nextStreak,
+          staleFindingCount: loopAssessment.staleFindings.length });
+        deps.log('review.loop-breaker', { pr, head: diffRead.headCommit, state: loopState,
+          ...(loopReason ? { reason: loopReason } : {}), staleReopenRounds: nextStreak,
+          staleFindingCount: loopAssessment.staleFindings.length },
+        { level: loopState === 'clear' ? 'info' : 'warn' });
       }
     }
     reviewPin?.remove();
@@ -2661,12 +2878,22 @@ async function runSelfReviewCliCommandPinned(
       continue;
     }
     const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-    const jsonReview = review.reviewed === true ? review : { ...review, verdict: null };
+    const jsonReview = review.reviewed === true ? review : { ...review, verdict: null,
+      ...(deltaHeal ? { failureReason: safeLogText(review.failureReason || 'reviewed-false', 400) } : {}) };
     // ⛔ 금지 백엔드가 낸 판정은 «근거 거부»다 — verdict·mustFix 를 그대로 실어 보내면 읽는 쪽이
     //    그것을 착지 판정으로 쓴다(관문도 reviewed===true 를 근거 조건으로 본다).
     const refusalOverride = landingGateAdmitted ? {} : { reviewed: false, verdict: null, refusal: 'review-forbidden-acp-backend' as const };
-    const resultOutput = { pr, model: selectedModel, ...jsonReview, reviewInputChars, reviewDurationMs,
-      ...(deltaBase ? deltaReceipt : {}), ...reviewProvenance, ...respondedOutput, ...reviewerSelection,
+    const deltaHealResult = safeLogText(review.reviewed === true && landingGateAdmitted
+      ? `verdict-${review.verdict}` : `refused-${review.failureReason || (landingGateAdmitted ? 'reviewed-false' : 'landing-gate')}`, 400);
+    if (deltaHeal) deps.log('review.delta-heal', { pr, cause: deltaHeal.cause,
+      prescription: deltaHeal.prescription, result: deltaHealResult, headCommit: diffRead.headCommit },
+    { level: review.reviewed === true && landingGateAdmitted ? 'info' : 'warn' });
+    const deltaHealOutput = deltaHeal ? {
+      ...(deltaBase ? {} : { deltaOutcome: review.reviewed === true && landingGateAdmitted ? 'healed-full-review' : 'refused' }),
+      deltaHeal: { ...deltaHeal, result: deltaHealResult },
+    } : {};
+    const resultOutput = { pr, model: selectedModel, ...jsonReview, ...loopBreakerOutput, reviewInputChars, reviewDurationMs,
+      ...(deltaBase ? deltaReceipt : {}), ...deltaHealOutput, ...reviewProvenance, ...respondedOutput, ...reviewerSelection,
       ...reviewCwdOutput, ...provenance, ...contextOutput, ...refusalOverride, ...landingGateFields,
       findingPathHeadChecks, pathWarnings, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles,
       ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) };