elanous 0.2.22 → 0.2.24

package/src/self-implement/review-finding-recurrence.ts

@@ -41,6 +41,34 @@ export interface RecurrenceFinding {
   readonly item: string;
 }
 
+/** Pod 리뷰 예산 소진 잔여 분류(FLEX-POD-ACCEPT-1).
+ *  `repeatedIds` = 앞 라운드와 id(내용 해시) 또는 비지 않은 `reviewFindingKey` 가 같은 지적.
+ *  `keyOnlyRepeatedIds` = 그중 «키로만» 반복된 것(문면이 달라 내용 해시는 다르다).
+ *  ⛔ 사양 v2(OP 18:1x (a)): Pod 수락은 «전부 내용 해시 반복»일 때만 — 키로만 반복된 지적은 관측만 하고 수락 근거로 쓰지 않는다. */
+export function classifyPodReviewBudgetResidue(
+  current: readonly RecurrenceFinding[] | undefined,
+  previous: readonly RecurrenceFinding[] | undefined,
+): { status: 'all-repeated' | 'has-new' | 'unmeasured'; repeatedIds: string[]; newIds: string[]; keyOnlyRepeatedIds: string[] } {
+  if (!previous?.length || !current?.length) return { status: 'unmeasured', repeatedIds: [], newIds: [], keyOnlyRepeatedIds: [] };
+  const previousIds = new Set(previous.map(({ id }) => id));
+  const previousKeys = new Set(previous.map(({ item }) => reviewFindingKey(item).key).filter(Boolean));
+  const repeatedIds: string[] = [];
+  const newIds: string[] = [];
+  const keyOnlyRepeatedIds: string[] = [];
+  for (const { id, item } of current) {
+    if (previousIds.has(id)) {
+      repeatedIds.push(id);
+      continue;
+    }
+    const key = reviewFindingKey(item).key;
+    if (key !== '' && previousKeys.has(key)) {
+      repeatedIds.push(id);
+      keyOnlyRepeatedIds.push(id);
+    } else newIds.push(id);
+  }
+  return { status: newIds.length ? 'has-new' : 'all-repeated', repeatedIds, newIds, keyOnlyRepeatedIds };
+}
+
 export interface AcceptedRefutationHistory {
   /** 반박이 수용되어 앞 라운드에 기각된 stable must-fix ID. */
   readonly acceptedRefutationFindingIds?: readonly string[];

package/src/self-implement/rework-policy.ts

@@ -459,6 +459,7 @@ export function applyReworkBudgetDecision(
   priorRounds = Number.POSITIVE_INFINITY,
   shadowStop = false,
   previousVerdict?: ReworkBudgetVerdict,
+  gateBaselineOnly?: boolean,
 ): { effectiveMax: number; stop: boolean; exit: 'continue' | 'proceed' | 'blocked'; applied: boolean; shadowed?: boolean; wouldExit?: 'proceed' | 'blocked'; contractConflictDisposition?: ContractConflictDisposition } {
   const cap = Math.max(0, hardCap);
   const normalizedMax = Math.min(cap, Math.max(0, effectiveMax));
@@ -482,7 +483,7 @@ export function applyReworkBudgetDecision(
     return { effectiveMax: extendedMax, stop: false, exit: 'continue', applied: extendedMax > normalizedMax };
   }
   if (decision.verdict === 'SUFFICIENT') {
-    if (kind !== 'review') return { effectiveMax: normalizedMax, stop: false, exit: 'continue', applied: false };
+    if (kind !== 'review' && !(kind === 'gate' && gateBaselineOnly === true)) return { effectiveMax: normalizedMax, stop: false, exit: 'continue', applied: false };
     return shadowStop
       ? { effectiveMax: normalizedMax, stop: false, exit: 'continue', applied: false, shadowed: true, wouldExit: 'proceed' }
       : { effectiveMax: normalizedMax, stop: true, exit: 'proceed', applied: true };

package/src/self-implement/round-summary-card.ts

@@ -0,0 +1,63 @@
+export interface RoundSummaryEntry {
+  /** The round whose result this entry records; zero is the first implementation. */
+  round: number;
+  kind: 'gate' | 'review';
+  tried?: string;
+  failedIds?: readonly string[];
+  filesTouched?: readonly string[];
+  rung?: string;
+  premiseFindings?: readonly string[];
+}
+
+const HEADER = '[라운드 요약 카드 — 이미 해 본 수와 결과]';
+
+function singleLine(value: string): string {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function list(items: readonly string[] | undefined): string {
+  return items === undefined ? '못 쟀다' : items.length === 0 ? '0건' : items.map(singleLine).join(', ');
+}
+
+function failureKey(entry: RoundSummaryEntry): string | undefined {
+  return entry.failedIds?.length ? JSON.stringify([...new Set(entry.failedIds)].sort()) : undefined;
+}
+
+/** Only recorded results are rendered; no filesystem or runtime state is consulted. */
+export function renderRoundSummaryCard(entries: readonly RoundSummaryEntry[], { maxChars = 1500 }: { maxChars?: number } = {}): string {
+  if (!entries.length) return '';
+  const lines = entries.map((entry) => `라운드 ${entry.round} · ${entry.kind} · 해 본 수: ${entry.tried === undefined ? '못 쟀다' : singleLine(entry.tried)} · 실패 id: ${list(entry.failedIds)} · 손댄 파일: ${list(entry.filesTouched)}`
+    + (entry.rung === undefined ? '' : ` · rung: ${singleLine(entry.rung)}`)
+    + (entry.premiseFindings === undefined ? '' : ` · premiseFindings: ${list(entry.premiseFindings)}`));
+  const lastKey = failureKey(entries[entries.length - 1]!);
+  const prior = lastKey === undefined ? undefined : entries.slice(0, -1).find((entry) => failureKey(entry) === lastKey);
+  const guidance = prior === undefined ? '' : [
+    `이 실패 집합은 라운드 ${prior.round} 에서도 같았다 — 같은 수 대신 다른 칸을 열 수 있다.`,
+    '이렇게 하라: (F1) base(origin/main)에서 같은 시험을 돌려 원래 깨진 것인지 보고, 호출자와 `git log -S <심볼>`로 선례를 보라.',
+    '(F2) docs/의 매뉴얼·FINDING에서 같은 증상을 찾아라. 원인이 이 골의 범위 밖이라면 근거(파일:줄·명령 출력)를 PR 본문 «남은 것»에 적어라.',
+  ].join('\n');
+  const render = (omitted: number) => [HEADER, ...(omitted ? [`…(앞 라운드 ${omitted}개 생략)`] : []), ...lines.slice(omitted), ...(guidance ? [guidance] : [])].join('\n');
+  let omitted = 0;
+  while (omitted < lines.length - 1 && render(omitted).length > maxChars) omitted++;
+  const card = render(omitted);
+  if (card.length <= maxChars) return card;
+  // Reserve the repeated-failure actions before truncating the latest round's details.
+  const latestEntry = entries[entries.length - 1]!;
+  const latest = lines[lines.length - 1]!;
+  const identity = `라운드 ${latestEntry.round} · ${latestEntry.kind}`;
+  const marker = omitted ? `…(앞 라운드 ${omitted}개 생략)\n` : '';
+  const heading = `${HEADER}\n`;
+  const prefix = heading.length + marker.length + identity.length <= maxChars ? heading + marker
+    : heading.length + identity.length <= maxChars ? heading
+    : '';
+  const available = Math.max(0, maxChars - prefix.length);
+  if (available < identity.length) return identity.slice(0, available);
+  const fullAdvice = guidance ? `\n${guidance}` : '';
+  const shortAdvice = prior ? `\n라운드 ${prior.round} 실패 반복 — base 시험을 확인하고 다른 칸을 열어라.` : '';
+  const advice = identity.length + fullAdvice.length <= available ? fullAdvice
+    : identity.length + shortAdvice.length <= available ? shortAdvice : '';
+  const resultBudget = available - advice.length;
+  const visible = latest.length <= resultBudget ? latest
+    : resultBudget > identity.length ? `${latest.slice(0, resultBudget - 1)}…` : identity;
+  return prefix + visible + advice;
+}

package/src/self-implement/run-ledger.ts

@@ -2,14 +2,14 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statS
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { refuseProductionLedgerWriteInTest } from '../harness/ledger-write-guard.js';
 import { tracedPathReferences, verbatimOriginalAsk } from './goal-author.js';
-import { parseAskTargetPathHintsResult } from '../self-dev/launch-preflight.js';
+import { parseAskTargetPathHintsResult } from '../self-dev/launch-preflight-text.js';
 import { isRunStatus } from './run-status-mapping.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { normalizeRunId } from '../harness/harness-space.js';
 import { resolveLogTargets, type LogTarget } from '../cli/logs-cli.js';
 import { LogStore, logsDbPath, type LogStoreRow } from '../mss/logging/log-store.js';
 import { loadSelfDevRun, selfDevRunsDir } from '../self-dev/run-store.js';
-import { extractHarnessReviewAcceptance } from '../harness/harness-seams.js';
+import { extractHarnessReviewAcceptance } from './goal-digest.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
 import { debug } from '../debug/log.js';
 import { withRunLedgerLock, restoreArchivedRunLedger } from './run-ledger-compact.js';
@@ -1561,7 +1561,8 @@ interface UnfinishedLedgerFacts {
   fixedLifecycle: UnfinishedRunLifecycle;
 }
 
-const UNFINISHED_LEDGER_CACHE_LIMIT = 5_000;
+// A full federated scan can exceed 5,000 files; keep the previous scan resident for mtime-checked reuse.
+const UNFINISHED_LEDGER_CACHE_LIMIT = 32_768;
 const unfinishedLedgerCache = new Map<string, { size: number; mtimeMs: number; facts: UnfinishedLedgerFacts }>();
 const unfinishedReaderIds = new WeakMap<RunLedgerReader, number>();
 let nextUnfinishedReaderId = 1;

package/src/self-implement/run-step-projection.ts

@@ -0,0 +1,147 @@
+import type { RunLedgerEntry } from './run-ledger.js';
+
+export type RunStep =
+  | { seq: number; ts: string; type: 'node-enter'; node: string; visit: number }
+  | { seq: number; ts: string; type: 'node-exit'; node: string; outcome: string }
+  | { seq: number; ts: string; type: 'edge-taken'; from: string; to: string; via: string; condition?: string }
+  | { seq: number; ts: string; type: 'node-skipped'; node: string; reason: string; condition?: string }
+  | { seq: number; ts: string; type: 'node-added'; node: string; kind: string; decider: string; reason: string; trigger?: unknown; undo?: unknown }
+  | { seq: number; ts: string; type: 'edge-rerouted'; from: string; outcome: string; to: string; was: string; decider: string; reason: string }
+  | { seq: number; ts: string; type: 'unit-expanded'; node: string; unit: string; childRunId: string; resolution: number; decider: string; reason: string }
+  | { seq: number; ts: string; type: 'unit-collapsed'; node: string; resolution: number; decider: string; reason: string };
+
+export interface RunStepProjection {
+  runId: string;
+  graph: { graphId: string | null; version: string | null; variantHash: string | null };
+  steps: readonly RunStep[];
+  complete: boolean;
+  /** Number of recognized steps whose source record could not be projected. */
+  unreadable: number;
+  /** Source sequence and reason for every rejected or duplicate step. */
+  violations: readonly { seq: number | null; reason: string }[];
+}
+
+const STEP_EVENTS = new Set([
+  'node-enter', 'node-exit', 'edge-taken', 'node-skipped',
+  'node-added', 'edge-rerouted', 'unit-expanded', 'unit-collapsed',
+  'pipeline-node-entry', 'pipeline-node-exit', 'graph-edge-taken',
+]);
+const STRUCTURAL_EVENTS = new Set(['node-added', 'edge-rerouted', 'unit-expanded', 'unit-collapsed']);
+
+function text(data: Record<string, unknown>, key: string): string | null {
+  const value = data[key];
+  return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+
+function validSeq(value: unknown): value is number {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+
+function stepType(entry: RunLedgerEntry): string | null {
+  if (STEP_EVENTS.has(entry.event)) {
+    if (entry.event === 'pipeline-node-entry') return 'node-enter';
+    if (entry.event === 'pipeline-node-exit') return 'node-exit';
+    if (entry.event === 'graph-edge-taken') return 'edge-taken';
+    return entry.event;
+  }
+  if (entry.event === 'applied' && entry.data.op === 'add-node') return 'node-added';
+  if (entry.event === 'applied' && entry.data.op === 'reroute') return 'edge-rerouted';
+  if (entry.event === 'applied' && entry.data.op === 'zoom-in') return 'unit-expanded';
+  if (entry.event === 'applied' && entry.data.op === 'collapse') return 'unit-collapsed';
+  return null;
+}
+
+function projectStep(entry: RunLedgerEntry, type: string, seq: number): RunStep | string {
+  const data = entry.data;
+  const ts = entry.timestamp;
+  if (typeof ts !== 'string' || !Number.isFinite(Date.parse(ts))) return 'timestamp missing or invalid';
+  const node = text(data, 'node');
+  const condition = text(data, 'condition');
+  if (STRUCTURAL_EVENTS.has(type) && (!text(data, 'decider') || !text(data, 'reason'))) {
+    return 'structural change requires decider and reason';
+  }
+  switch (type) {
+    case 'node-enter': {
+      const visit = data.visit;
+      return node && validSeq(visit) ? { seq, ts, type, node, visit } : 'node-enter requires node and positive visit';
+    }
+    case 'node-exit': {
+      const outcome = text(data, 'outcome');
+      return node && outcome ? { seq, ts, type, node, outcome } : 'node-exit requires node and outcome';
+    }
+    case 'edge-taken': {
+      const from = text(data, 'from');
+      const to = text(data, 'taken') ?? text(data, 'to');
+      const via = text(data, 'via') ?? (entry.event === 'graph-edge-taken' ? data.source === 'graph' ? 'outcome' : 'fallback' : null);
+      return from && to && via ? { seq, ts, type, from, to, via, ...(condition ? { condition } : {}) } : 'edge-taken requires from, to and via';
+    }
+    case 'node-skipped': {
+      const reason = text(data, 'reason');
+      return node && reason ? { seq, ts, type, node, reason, ...(condition ? { condition } : {}) } : 'node-skipped requires node and reason';
+    }
+    case 'node-added': {
+      const kind = text(data, 'kind');
+      return node && kind ? { seq, ts, type, node, kind, decider: text(data, 'decider')!, reason: text(data, 'reason')!, ...(data.trigger === undefined ? {} : { trigger: data.trigger }), ...(data.undo === undefined ? {} : { undo: data.undo }) } : 'node-added requires node and kind';
+    }
+    case 'edge-rerouted': {
+      const from = text(data, 'from');
+      const outcome = text(data, 'outcome');
+      const to = text(data, 'to');
+      const was = text(data, 'was');
+      return from && outcome && to && was ? { seq, ts, type, from, outcome, to, was, decider: text(data, 'decider')!, reason: text(data, 'reason')! } : 'edge-rerouted requires from, outcome, to and was';
+    }
+    case 'unit-expanded': {
+      const unit = text(data, 'unit') ?? text(data, 'into');
+      const childRunId = text(data, 'childRunId');
+      const resolution = data.resolution;
+      return node && unit && childRunId && typeof resolution === 'number' && Number.isSafeInteger(resolution) && resolution >= 0
+        ? { seq, ts, type, node, unit, childRunId, resolution, decider: text(data, 'decider')!, reason: text(data, 'reason')! }
+        : 'unit-expanded requires node, unit, childRunId and resolution';
+    }
+    case 'unit-collapsed': {
+      const resolution = data.resolution;
+      return node && typeof resolution === 'number' && Number.isSafeInteger(resolution) && resolution >= 0
+        ? { seq, ts, type, node, resolution, decider: text(data, 'decider')!, reason: text(data, 'reason')! }
+        : 'unit-collapsed requires node and resolution';
+    }
+    default: return 'unrecognized step';
+  }
+}
+
+/** Pure projection of already-read JSONL records; never guesses a sequence from timestamps or line positions. */
+export function projectRunLedgerSteps(runId: string, entries: readonly RunLedgerEntry[]): RunStepProjection {
+  const steps: RunStep[] = [];
+  const violations: { seq: number | null; reason: string }[] = [];
+  const seen = new Set<number>();
+  let graphId: string | null = null;
+  let version: string | null = null;
+  let variantHash: string | null = null;
+  for (const entry of entries) {
+    if (entry.runId !== runId) continue;
+    graphId = text(entry.data, 'graphId') ?? graphId;
+    version = text(entry.data, 'graphVersion') ?? version;
+    variantHash = text(entry.data, 'variantHash') ?? variantHash;
+    const type = stepType(entry);
+    if (!type) continue;
+    const topLevelSeq = (entry as RunLedgerEntry & { seq?: unknown }).seq;
+    const seq = topLevelSeq ?? entry.data.seq;
+    if (topLevelSeq !== undefined && entry.data.seq !== undefined && topLevelSeq !== entry.data.seq) {
+      violations.push({ seq: validSeq(topLevelSeq) ? topLevelSeq : null, reason: 'conflicting step seq' });
+      continue;
+    }
+    if (!validSeq(seq)) {
+      violations.push({ seq: null, reason: 'step requires positive safe-integer seq' });
+      continue;
+    }
+    if (seen.has(seq)) {
+      violations.push({ seq, reason: 'duplicate step seq' });
+      continue;
+    }
+    seen.add(seq);
+    const step = projectStep(entry, type, seq);
+    if (typeof step === 'string') violations.push({ seq, reason: step });
+    else steps.push(step);
+  }
+  steps.sort((a, b) => a.seq - b.seq);
+  return { runId, graph: { graphId, version, variantHash }, steps, complete: violations.length === 0, unreadable: violations.length, violations };
+}

package/src/self-implement/run-stop.ts

@@ -63,7 +63,7 @@ export function classifyMergeHoldStop(mergeReason: string | undefined): RunStopC
   const reason = mergeReason ?? '';
   if (reason.startsWith('main-sync') || reason === 'default-branch-unresolved') return 'main-sync';
   if (reason === 'required-evidence-uncovered') return 'evidence-uncovered';
-  if (reason === 'review-must-fix' || reason.startsWith('review-budget')) return 'review-repeat';
+  if (reason === 'review-must-fix' || reason === 'review-warn-with-must-fix' || reason.startsWith('review-budget')) return 'review-repeat';
   if (reason.startsWith('review-diff') || reason === 'no-real-review') return 'review-out-of-scope';
   return 'unclassified';
 }

package/src/self-implement/running-runs.ts

@@ -566,13 +566,83 @@ export function queryRunningRuns(options: { includeTest?: boolean; runIds?: read
   }
 }
 
-export function renderRunningRuns(result: RunningRunsResult): string {
-  const lingeringLaunchParents = result.lingeringLaunchParents ?? { observation: 'indeterminate' } as const;
-  const partial = (result.count !== undefined && typeof result.count !== 'number' && result.count.count === null)
+function isPartialRunningRuns(result: RunningRunsResult): boolean {
+  return (result.count !== undefined && typeof result.count !== 'number' && result.count.count === null)
     || result.completeness === 'partial' || hasUnreadableLedgerObservation(result.ledger) || (result.unreadable?.length ?? 0) > 0;
-  const lowerBound = result.count !== undefined && typeof result.count !== 'number'
+}
+
+function runningRunsLowerBound(result: RunningRunsResult): number {
+  return result.count !== undefined && typeof result.count !== 'number'
     ? result.count.lowerBound : result.counts.running + result.counts['probable-running'];
-  const unreadable = result.unreadable ?? (result.count !== undefined && typeof result.count !== 'number' ? result.count.unreadable : []);
+}
+
+function runningRunsUnreadable(result: RunningRunsResult): readonly UnreadableRunningRunsLedger[] {
+  return result.unreadable ?? (result.count !== undefined && typeof result.count !== 'number' ? result.count.unreadable : []);
+}
+
+export interface RunProgressRow {
+  readonly runId: string;
+  readonly status: RunningRunStatus;
+  /** null = no phase observed; never rendered as «none». */
+  readonly lastPhase: string | null;
+  readonly lastPhaseObservedAt: string | null;
+  readonly lastActivityTimestamp: string | null;
+  /** Milliseconds since lastActivityTimestamp; null when the timestamp is absent or unparseable. */
+  readonly elapsedMs: number | null;
+  readonly ptyRefs: readonly string[];
+  readonly phaseObservation: RunningRunPhaseObservation;
+}
+
+export function buildRunProgressRows(result: RunningRunsResult, nowMs: number = Date.now()): RunProgressRow[] {
+  return result.entries.map((entry) => {
+    const activityMs = entry.lastActivityTimestamp === null ? Number.NaN : Date.parse(entry.lastActivityTimestamp);
+    return {
+      runId: entry.runId,
+      status: entry.status,
+      lastPhase: entry.lastPhase ?? null,
+      lastPhaseObservedAt: entry.lastPhaseObservedAt ?? null,
+      lastActivityTimestamp: entry.lastActivityTimestamp,
+      elapsedMs: Number.isFinite(activityMs) ? Math.max(0, nowMs - activityMs) : null,
+      ptyRefs: entry.ptyRefs.map((ref) => `${ref.instance}:${ref.id}`),
+      phaseObservation: entry.phaseObservation ?? 'not-observed',
+    };
+  });
+}
+
+function formatElapsed(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const days = Math.floor(totalSeconds / 86_400);
+  const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+  const minutes = Math.floor((totalSeconds % 3_600) / 60);
+  const seconds = totalSeconds % 60;
+  if (days > 0) return `${days}d${hours}h`;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m${seconds}s`;
+  return `${seconds}s`;
+}
+
+export function renderRunProgressTable(result: RunningRunsResult, nowMs: number = Date.now()): string {
+  const partial = isPartialRunningRuns(result);
+  const header = partial
+    ? `부분 관측 — 최소 ${runningRunsLowerBound(result)} (읽지 못한 원장: ${runningRunsUnreadable(result).map((item) => `${item.dir}:${item.reason}`).join(',') || '없음'})`
+    : `도는 런 ${result.counts.running + result.counts['probable-running']} (확인 ${result.counts.running} · 추정 ${result.counts['probable-running']})`;
+  const rows = buildRunProgressRows(result, nowMs).map((row) => {
+    const phaseUnreadable = row.phaseObservation === 'unreadable' || row.phaseObservation === 'partially-unreadable';
+    const phase = row.lastPhase ?? (phaseUnreadable ? '미관측 (단계 저장소 읽기 실패)' : '미관측');
+    const phaseAt = row.lastPhaseObservedAt ?? '미관측';
+    const progress = row.lastActivityTimestamp === null
+      ? '미관측'
+      : `${row.lastActivityTimestamp} (경과 ${row.elapsedMs === null ? '알 수 없음' : formatElapsed(row.elapsedMs)})`;
+    return `${row.runId} · ${row.status} · 단계 ${phase} · 진입 ${phaseAt} · 마지막 진전 ${progress} · pty ${row.ptyRefs.join(',') || '없음'}`;
+  });
+  return [header, ...rows].join('\n');
+}
+
+export function renderRunningRuns(result: RunningRunsResult): string {
+  const lingeringLaunchParents = result.lingeringLaunchParents ?? { observation: 'indeterminate' } as const;
+  const partial = isPartialRunningRuns(result);
+  const lowerBound = runningRunsLowerBound(result);
+  const unreadable = runningRunsUnreadable(result);
   return [
     partial
       ? `running runs: unknown (at least ${lowerBound}) unreadable: ${unreadable.map((item) => `${item.dir}:${item.reason}`).join(',')}`

package/src/self-implement/seams.ts

@@ -23,16 +23,18 @@ import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
 import { forkSessionById, HARNESS_SESSION_ORIGIN, isHarnessSessionOrigin } from '../session/index.js';
-import { configuredWorktreeRoot, getUserConfig, resolveRoleLlm } from '../user-config.js';
+import { configuredWorktreeRoot, getUserConfig, resolveActiveProvider, resolveRoleLlm } from '../user-config.js';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { addHarnessQueue } from '../harness/harness-queue.js';
 import { readFollowUpMode } from './follow-up-goals.js';
-import { getProviderForConfig } from '../llm.js';
+import { getProviderForConfig, NoLlmProviderAvailableError } from '../llm.js';
+import { lookupLlmTierSpec } from '../model-tier/llm-tier-map.js';
 import { createWorktree, DEFAULT_BRANCH_WORKTREE_BASE, linkWorktreeDependencies, removeWorktree, resolveDefaultBranchBase, resolveMainRepoRoot } from '../git-fs/worktree.js';
 import { isWorktreeInUse, listActiveTerminalDirectories } from '../harness/harness-clean.js';
 import { readWorktreePorcelain } from './abandoned-classification.js';
 import { recordHarnessWorktreeGoalMetadata, recordHarnessWorktreeProvenance, type HarnessWorktreeGoalMetadata } from '../harness/harness-worktree-add.js';
 import { runGitCommand } from '../git-fs/runner.js';
+import { BENCH_LABEL, BENCH_LOG_CATEGORY, benchIdFromBase, parseBenchArmBranch } from '../bench/bench.js';
 import { provisionDerivedUniverse } from '../instance/provision.js';
 import { DEFAULT_GATE_STEPS, runIntegrityGate, type GateResult, type GateStepName } from '../autopilot/build/integrity-gate.js';
 import { androidFilesIn, runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
@@ -93,6 +95,7 @@ import { isSupervisorDecisionSection, splitGoalSections, supervisorGoalDigest }
 import type { SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ReworkBudgetVerdict } from './run-outcome.js';
 import { pickImplementRoleForGoal, runHeadlessGoalLoopPty } from './headless-elanous-driver.js';
+import { isClaudeAcpChild, runClaudeAcpImplement } from './claude-acp-implement.js';
 import { childLlmSelectionEnv } from '../agent/run-context.js';
 import { observeExternalEvent } from '../context-bus/external-events.js';
 import { buildLlmHitlRelay, SIDE_EFFECT_RE } from '../harness/llm-hitl-relay.js';
@@ -198,7 +201,39 @@ export const SELF_IMPLEMENT_COMPLETION_REPORT_HINT = '자식이 최종 요약
 
 /** self-implement 실행 경계가 범용 brain에 전용 종료-보고 규칙을 주입한다. */
 export function createSelfImplementControlBrain(opts: Omit<LlmControlBrainOpts, 'systemHint'>) {
-  return createLlmControlBrain({ ...opts, systemHint: SELF_IMPLEMENT_COMPLETION_REPORT_HINT });
+  // ⭐ 이 부모에 쓸 provider 가 «하나도» 없으면(NoLlmProviderAvailableError) BRAIN-FAST 이전처럼 «지연 해석»
+  //   brain 을 돌려준다 — 생성 시점에 throw 하면 implement seam 전체가 자식을 띄우기도 전에 죽는다
+  //   (0.2.23 게이트 회귀 · 자식 LLM 은 따로 정해질 수 있다). provider 결정은 decide 시점 streamLLM 이 다시 한다.
+  //   ⛔ 다른 오류(예: provider 충돌)는 그대로 던진다.
+  const deferred = (error: unknown): ReturnType<typeof createLlmControlBrain> => {
+    if (!(error instanceof NoLlmProviderAvailableError)) throw error;
+    debug.log('self-implement', 'brain.model', { provider: null, model: opts.model ?? null, source: 'unresolved-deferred' }, { level: 'warn' });
+    return createLlmControlBrain({ ...opts, systemHint: SELF_IMPLEMENT_COMPLETION_REPORT_HINT });
+  };
+  let role: ReturnType<typeof resolveRoleLlm>;
+  try {
+    role = resolveRoleLlm('classify');
+  } catch (error) {
+    return deferred(error);
+  }
+  const explicit = role.source === 'flag' || role.source === 'config-role';
+  if (!opts.model && opts.provider && explicit && opts.provider !== role.provider) {
+    throw new Error(`brain provider conflict: caller=${opts.provider}, classify=${role.provider}`);
+  }
+  let provider: ReturnType<typeof resolveActiveProvider>;
+  try {
+    provider = opts.model ? (opts.provider ?? resolveActiveProvider(getUserConfig()))
+      : explicit ? role.provider : (opts.provider ?? resolveActiveProvider(getUserConfig()));
+  } catch (error) {
+    return deferred(error);
+  }
+  const budget = !opts.model && !explicit ? lookupLlmTierSpec(provider, 'budget') : undefined;
+  const model = opts.model ?? (explicit ? role.model : budget!.model);
+  const source = opts.model ? 'caller' : explicit ? role.source : 'tier-budget';
+  debug.log('self-implement', 'brain.model', { provider, model, source });
+  return createLlmControlBrain({ ...opts, model, provider,
+    ...(budget?.reasoningLevel ? { reasoningLevel: budget.reasoningLevel } : {}),
+    systemHint: SELF_IMPLEMENT_COMPLETION_REPORT_HINT });
 }
 
 function git(cwd: string, argv: string[]): { ok: boolean; out: string; stdout: string } {
@@ -1034,6 +1069,8 @@ export interface DefaultSeamsOptions {
   buildLlmHitlRelay?: typeof buildLlmHitlRelay;
   /** 테스트용 PTY executor 주입. */
   runHeadlessGoalLoopPty?: typeof runHeadlessGoalLoopPty;
+  /** CLAUDE-IMPL-LANE 시험 주입 — claude-acp 자식의 구독 ACP 구현 실행. */
+  runClaudeAcpImplement?: typeof runClaudeAcpImplement;
   /** 테스트용 PTY 가용성 주입. */
   ptyAvailable?: () => boolean;
   /** Tests may inject the shared provenance writer to exercise the self-implement failure contract. */
@@ -1334,6 +1371,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
   const removeCleanupWorktree = o.removeWorktree ?? removeWorktree;
   const runCleanupGitCommand = o.runGitCommand ?? runGitCommand;
   const baselineRefs = new Map<string, string>();
+  // BENCH-ISOLATED-ARMS — 벤치 base(`bench/<id>/base`) 위에서 만든 작업 트리 → bench id.
+  const benchWorktrees = new Map<string, string>();
   const gateVerifyOrdinals = new Map<string, number>();
   const gateVerifyIdentity = (runId: string | undefined) => {
     if (!runId?.trim()) return { runId: runId === undefined ? null : runId, ordinal: null };
@@ -1502,6 +1541,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     defaultBranchRef,
     // ★ G2(2026-07-21) — 호출부가 해석한 대상만 PR 직전에 정합한다.
     mergeMain: async (worktreePath, mergeTarget) => {
+      // BENCH-ISOLATED-ARMS ③ — 벤치 팔은 main 에 정합하지 않는다: 판정은 고정 base 위 게이트·시험·리뷰.
+      //   ⭐ 표지는 둘 중 하나 — 이 프로세스가 벤치 base 로 만든 트리이거나, 트리 가지가 `bench/<id>/<arm>` 이다
+      //   (재개 프로세스는 앞의 Map 이 비어 있으므로 가지 이름으로 다시 안다).
+      const benchArm = benchWorktrees.has(worktreePath) ? undefined : (() => {
+        const head = runGitCommand(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8', timeout: GIT_TIMEOUT });
+        return head.status === 0 ? parseBenchArmBranch(String(head.stdout).trim()) : null;
+      })();
+      const benchId = benchWorktrees.get(worktreePath) ?? benchArm?.id;
+      if (benchId) {
+        debug.log(BENCH_LOG_CATEGORY, 'main-sync-skipped', { benchId, worktreePath, mergeTarget, source: benchWorktrees.has(worktreePath) ? 'base' : 'branch' });
+        return { status: 'up-to-date' as const };
+      }
       const { mergeMainIntoWorktreeWithLlm } = await import('../autopilot/build/llm-conflict-merge.js');
       return mergeMainIntoWorktreeWithLlm(worktreePath, mergeTarget);
     },
@@ -1553,6 +1604,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { currentOwner: `dev:${runId}` } : {}),
       });
       if (r.resolvedBase) baselineRefs.set(r.path, r.resolvedBase);
+      const benchId = benchIdFromBase(base);
+      if (benchId) benchWorktrees.set(r.path, benchId);
       const provenance = runId ? {
         owner: `dev:${runId}`,
         command: 'elanous dev',
@@ -1653,6 +1706,28 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { runId } : {}),
       });
       const prompt = featurePrompt(feature, cwd, o.reviewerContext);
+      // CLAUDE-IMPL-LANE — claude-acp 는 PTY 자식(`elanous chat` → getProvider)으로 보내지 않는다:
+      //   거기서는 모델 이름(claude-…)이 anthropic(API 키 provider)으로 풀려 «구독» 런이 API 로 과금된다(#26277 보류 판독).
+      //   구독 ACP 구현기만 쓰고, 구독 확인이 안 되면 실패로 끝낸다(다른 공급자로 조용히 새지 않는다).
+      if (isClaudeAcpChild(childLlm)) {
+        const outcome = await (o.runClaudeAcpImplement ?? runClaudeAcpImplement)({
+          cwd, prompt, ...(childLlm?.model ? { model: childLlm.model } : {}), ...(runId ? { runId } : {}),
+        });
+        if (outcome.kind === 'refused') {
+          debug.log('self-implement', 'implement.result', { reached: false, changed: false, transport: 'claude-acp', refused: outcome.reason, ...(runId ? { runId } : {}) });
+          return { ok: false, summary: `claude-acp 구현 레인 거부: ${outcome.reason}` };
+        }
+        const changed = worktreeHasChanges(cwd, harnessSeededPaths ?? []);
+        // 도구 호출 수 = 허가를 요청한 호출(허가 ⊕ 거부) — ACP 는 읽기 전용 호출 일부를 묻지 않으니 하한이다.
+        const toolCalls = outcome.result.allowed + outcome.result.denied;
+        debug.log('self-implement', 'implement.result', { reached: true, changed, toolCalls, transport: 'claude-acp', allowed: outcome.result.allowed, denied: outcome.result.denied, ...(runId ? { runId } : {}) });
+        return {
+          ok: changed,
+          ...buildImplementReport(outcome.result.text, { changed, toolCalls, reached: true, timedOut: false }),
+          toolCalls,
+          terminalStatus: { reached: true, changed, toolCalls, timedOut: false },
+        };
+      }
       // S4 P2b/P3: input은 관측만 하며, done만 config와 stall 확증을 모두 만족할 때 부모 대기를 끝낸다.
       // 이 종료-보고 규칙은 self-implement child에만 적용한다. 범용 brain의 기본 프롬프트를 바꾸지 않는다.
       const brain = createSelfImplementControlBrain({ goal: feature });
@@ -2403,7 +2478,11 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
-        ...(labels?.length ? { labels } : {}),
+        // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 라벨 `elanous:bench` 를 더한다.
+        ...(() => {
+          const all = benchIdFromBase(resolvedBase) && !labels?.includes(BENCH_LABEL) ? [...(labels ?? []), BENCH_LABEL] : labels;
+          return all?.length ? { labels: all } : {};
+        })(),
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);

package/src/self-implement/self-implement-cli.ts

@@ -120,11 +120,15 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.abandonedClassification?.classification
       ? { failureClassification: r.abandonedClassification.classification } : {}),
     ...(r.decomposeProposal ? { decomposeProposal: r.decomposeProposal } : {}),
+    ...(r.rework ? { rework: r.rework } : {}),
+    ...(r.review?.reviewed && r.review.mustFix?.length ? { reviewMustFix: r.review.mustFix } : {}),
     ...(r.goalPlanRevision ? { goalPlanRevision: r.goalPlanRevision } : {}),
     ...(r.salvage !== undefined ? { salvage: r.salvage } : {}),
     ...(r.review?.reviewed === true && r.review.verdict === 'pass'
       && r.reviewedHeadCommit && /^[0-9a-f]{40}$/i.test(r.reviewedHeadCommit)
-      ? { selfReview: { verdict: r.review.verdict, head: r.reviewedHeadCommit } } : {}),
+      ? { selfReview: { verdict: r.review.verdict, head: r.reviewedHeadCommit,
+        // TA-LAND-MUSTFIX-ZERO — must-fix 수를 같이 나른다(목록이 없으면 «모름» = 안 싣는다 · land 관문이 막는다).
+        ...(Array.isArray(r.review.mustFix) && r.review.mustFix.every((fix) => typeof fix === 'string') ? { mustFixCount: r.review.mustFix.length } : {}) } } : {}),
     ...(r.review?.reviewed !== undefined ? { reviewed: r.review.reviewed } : {}),
     ...(r.review?.failureReason !== undefined ? { reviewReason: r.review.failureReason } : {}),
     // ⭐ 대표 지시(2026-09-08) — 걸음을 슈퍼바이저까지 나른다.
@@ -238,8 +242,10 @@ export async function runSelfImplementCliCommand(
           }
         : undefined;
 
+      const initialJob = singleRunAsJobResult(feature, result);
       await superviseRun({
-        initial: [singleRunAsJobResult(feature, result)],
+        initial: [initialJob],
+        repairGoalExecution: true,
         limits,
         ...(deliverableEye ? { observeDeliverables: deliverableEye } : {}),
         ...(opts.supervise.onDecision ? { onDecision: opts.supervise.onDecision } : {}),
@@ -248,11 +254,12 @@ export async function runSelfImplementCliCommand(
         },
         // ⛔ 단일의 「다시 걸기」는 «같은 골을 다시»다 — 연합의 resumeFrom 과 다르다.
         //   ⇒ 그래서 판정은 «같고» 집행만 여기서 안다(superviseRun 은 그것을 모른다).
-        rerun: async () => {
-          const next = await exec(spec, pipelineDeps ? { pipelineDeps } : undefined);
+        rerun: async (_, invocation) => {
+          const repairGoal = invocation.repairGoals?.[initialJob.taskId];
+          const next = await exec(repairGoal ? { ...spec, input: { ...spec.input, text: repairGoal } } : spec, pipelineDeps ? { pipelineDeps } : undefined);
           result = next.result;
           exitCode = next.exitCode;
-          return [singleRunAsJobResult(feature, next.result)];
+          return [{ ...singleRunAsJobResult(feature, next.result), taskId: initialJob.taskId }];
         },
       });
     }