elanous 0.2.23 → 0.2.25

package/src/seat-loop/seat-loop.ts

@@ -7,6 +7,8 @@ import { promisify } from 'node:util';
 import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot/track-agent.js';
 import { debug } from '../debug/log.js';
 import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { installedCliArgv, resolveHqLaunchSeat } from '../hq/seats.js';
 import { judgeNeighbor } from '../loops/neighbors.js';
 import { checkLoopNeighbors, emitLoopHeartbeat, SEAT_NEIGHBORS } from '../loops/neighbor-runtime.js';
 import { addHarnessQueue, harnessQueueIdForKey, harnessQueueOutcome, listHarnessQueue } from '../harness/harness-queue.js';
@@ -72,6 +74,8 @@ export type SeatDeps = {
   now?: () => Date;
   read?: (path: string) => string;
   run?: (args: string[]) => Promise<string>;
+  /** Seat-folder resolver for every process this loop starts; production reads the registry-validated `seats/<role>` view, tests inject an isolated folder. */
+  launchSeat?: (seat: string) => string;
   enqueue?: (seat: string, text: string, root: string, idempotencyKey: string, item: SeatItem) => Promise<{ id: string }>;
   queueOutcome?: (id: string, root: string) => ReturnType<typeof harnessQueueOutcome>;
   queueItems?: (root: string) => ReturnType<typeof listHarnessQueue>;
@@ -118,10 +122,27 @@ const defaultRead = (path: string): string => {
   try { return readFileSync(path, 'utf8'); }
   catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return ''; throw error; }
 };
-const defaultRun = async (args: string[]): Promise<string> => {
-  const { argv, env } = universeLaunch(args);
-  const { stdout } = await exec('bun', argv, {
-    cwd: repoRoot, env, encoding: 'utf8',
+/** The seat's own registry-validated folder (`seats/<role>`, kept fresh by `hq seat --refresh`) — never this module's source tree. */
+export function seatLoopLaunchSeat(seat: string): string {
+  return resolveHqLaunchSeat(seat, getElanousConfigDir());
+}
+/** One seat launch boundary: installed-CLI argv (absolute runtime + absolute entry) with `seats/<role>` as cwd. */
+export function seatLoopLaunchCommand(seat: string, args: readonly string[],
+  launchSeat: (role: string) => string = seatLoopLaunchSeat): { argv: string[]; cwd: string; env: NodeJS.ProcessEnv } {
+  let cwd: string;
+  try { cwd = launchSeat(seat); }
+  catch (error) {
+    // A missing seat folder is a stopped launch, never a fall back to the tree this code was loaded from.
+    observe('launch-seat-unavailable', { seat, error: String(error).slice(0, 200) });
+    throw new Error(`seat ${seat} has no registry-validated seats/${seat} folder; refusing to launch from the source tree: ${String(error)}`);
+  }
+  const { argv, env } = universeLaunch([...args]);
+  return { argv: installedCliArgv(argv.slice(1)), cwd, env };
+}
+const defaultRun = async (args: string[], seat: string, launchSeat?: (role: string) => string): Promise<string> => {
+  const { argv, cwd, env } = seatLoopLaunchCommand(seat, args, launchSeat ?? seatLoopLaunchSeat);
+  const { stdout } = await exec(argv[0]!, argv.slice(1), {
+    cwd, env, encoding: 'utf8',
     timeout: args[0] === 'harness' && args[1] === 'say' ? 3_600_000 : 120_000, maxBuffer: 4 * 1024 * 1024,
   });
   return stdout;
@@ -1203,6 +1224,8 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     return { seat, status: 'skipped-off',
       ...(config.mode === 'live-safe' ? { modeDowngradeReason: '자리 목록에 없음 (loops.seat.seats)' } : {}) };
   }
+  // Every process this turn starts runs through the installed CLI in the seat's own folder (`seats/<role>`, always fresh).
+  const run = deps.run ?? ((args: string[]): Promise<string> => defaultRun(args, seat, deps.launchSeat));
   const now = (deps.now ?? (() => new Date()))();
   const path = seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now);
   const directory = dirname(path);
@@ -1276,7 +1299,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
             current: `기한 ${waited}분 경과 · 칸 상태 ${cell?.status ?? '질문 미해결'}`, question, answer: '재측상 미해결이므로 보류를 권고한다',
             options, recommendation, confidence: '중간 — 기한 경과와 미해결을 재측함', ifUntouched: '질문/칸은 미해결로 남는다',
             evidence: `${proposal.item!.evidence ?? '원천 근거 미기재'} · ${note} · ${decisionRef(seat, proposal.item!)}` });
-          await (deps.run ?? defaultRun)(['decisions', 'raise', '--title', `${seat}: ${question}`, '--category', 'other',
+          await run(['decisions', 'raise', '--title', `${seat}: ${question}`, '--category', 'other',
             '--s', material.scqa.s, '--c', material.scqa.c, '--q', material.scqa.q, '--a', material.scqa.a,
             '--pending-question', material.pendingQuestion,
             '--option', 'a=승인:사람 판단으로 진행', '--option', 'b=보류:진행하지 않음',
@@ -1313,7 +1336,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
           const inputs = receivedInputs!;
           const evidence = judgmentEvidence;
           if (!evidence) throw new Error('cross-check judgment requires receiving-seat evidence');
-          const output = JSON.parse((await (deps.run ?? defaultRun)(['agent', '--json', '--no-tools',
+          const output = JSON.parse((await run(['agent', '--json', '--no-tools',
             `[${receiver} 자리 · 역할 docs/roles/${receiver}.md] ${from} 자리의 결정 초안을 교차 확인한다. 아래 실제 근거만 사용하고 모르는 사실은 지어내지 마라. JSON 하나만 반환: {"agree":boolean,"note":"근거를 포함한 메모","resolves":boolean}. 이웃 자리에서 직접 해결할 수 있을 때만 resolves=true. 초안: ${draft}\n역할: ${inputs.role}\n${receiver} 체크리스트 근거:\n${evidence || '(없음)'}`])).trim()) as { reply?: unknown };
           const value: unknown = typeof output.reply === 'string' ? JSON.parse(output.reply) : output;
           return value as CrossCheckJudgment;
@@ -1472,7 +1495,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
     const inquiry = item.source === 'seat-question' ? null : revisedProposal && item.source === 'checklist'
       ? ledger.find((row) => row.status === 'awaiting-resolution' && row.item && itemKey(row.item) === itemKey(item))?.inquiry ?? null
       : unfinished?.inquiry ?? await (deps.inquire ?? (async (asking: SeatId, work: SeatItem) => { try {
-      const output = JSON.parse((await (deps.run ?? defaultRun)(['agent', '--json', '--no-tools',
+      const output = JSON.parse((await run(['agent', '--json', '--no-tools',
         `[${asking} 자리 · 역할 docs/roles/${asking}.md] 이 항목을 판단할 근거가 부족한 경우에만 다른 자리 또는 사람에게 질문한다. 근거가 충분하면 null. JSON 객체 하나만 반환: null 또는 {"to":"OP|TC|MK|UX|CEO","question":"필요한 근거를 묻는 질문"}. 항목: ${work.id} ${work.title}\n내용: ${work.text}\n역할: ${(deps.read ?? defaultRead)(join(deps.repo ?? repoRoot, 'docs', 'roles', `${asking}.md`)).slice(0, 4_000)}`])).trim()) as { reply?: unknown };
       const value: unknown = typeof output?.reply === 'string' ? JSON.parse(output.reply) : output;
       if (value === null) return null;
@@ -1491,7 +1514,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       ? unfinished?.answer ? { answer: unfinished.answer } : unfinished?.inquiry ? unfinished.inquiry : await (deps.reply ?? (async (receiver: SeatId, question: string, from: SeatId) => {
       const evidence = inputs.checklist.map((candidate) =>
         `${candidate.id} · ${candidate.title} (판 ${candidate.version}, ${candidate.kind})${candidate.evidence?.trim() ? ` · 근거: ${candidate.evidence.trim()}` : ''}`).join('\n').slice(0, 8_000);
-      const output = JSON.parse((await (deps.run ?? defaultRun)(['agent', '--json', '--no-tools',
+      const output = JSON.parse((await run(['agent', '--json', '--no-tools',
         `[${receiver} 자리 · 역할 docs/roles/${receiver}.md] ${from} 자리의 질문에 근거를 갖고 답하라. 아래 ${receiver} 자리의 실제 체크리스트 근거에 없는 사실은 지어내지 마라. 모르면 사람 결정이 필요한 질문을 작성하라. JSON 하나만 반환: {"answer":"근거를 포함한 답"} 또는 {"to":"CEO","question":"결정할 질문"}. 질문: ${question}\n역할: ${inputs.role}\n${receiver} 체크리스트 근거:\n${evidence || '(없음)'}`])).trim()) as { reply?: unknown };
       const value: unknown = typeof output.reply === 'string' ? JSON.parse(output.reply) : output;
       if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid seat reply');
@@ -1592,7 +1615,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
                     question: ask.question, answer: '해소 근거 확인 전까지 보류를 권고한다', options, recommendation,
                     confidence: answer ? '중간 — 이웃 응답을 확인함' : '낮음 — 기한 내 이웃 응답 없음',
                     ifUntouched: '사람 판단 전 집행하지 않는다', evidence: `${item.evidence ?? '원천 근거 미기재'} · ${decisionRef(seat, item)}` });
-                  await (deps.run ?? defaultRun)(['decisions', 'raise', '--title', `${seat}: ${ask.question}`, '--category', 'other',
+                  await run(['decisions', 'raise', '--title', `${seat}: ${ask.question}`, '--category', 'other',
                     '--s', material.scqa.s, '--c', material.scqa.c, '--q', material.scqa.q, '--a', material.scqa.a,
                     '--pending-question', material.pendingQuestion,
                     '--option', 'a=승인:사람 판단으로 진행', '--option', 'b=보류:진행하지 않음',
@@ -1656,7 +1679,6 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       return entry;
     }
   }
-  const run = deps.run ?? defaultRun;
   let outcome: string | undefined;
   try { outcome = (JSON.parse(await run(['harness', 'budget', '--json'])) as { outcome?: string }).outcome; }
   catch { /* failed budget observation is never permission to launch */ }

package/src/self-dev/decompose.ts

@@ -14,8 +14,12 @@
  *
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21 §6 (S2).
  */
-import { tierModel } from '../llm/model-defaults.js';
 import { debug } from '../debug/log.js';
+import {
+  resolveRoleModel,
+  type ModelResolutionSource,
+  type UserConfig,
+} from '../user-config.js';
 import {
   gradePhaseCompletability,
   type CompletabilitySizeSignals,
@@ -598,9 +602,39 @@ export async function decomposeSelfDevGoal(
   return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
+/** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */
+export type DecomposeModelSource = 'explicit' | ModelResolutionSource;
+
+export interface DecomposeModelResolution {
+  model: string;
+  source: DecomposeModelSource;
+}
+
+export interface DecomposeModelDeps {
+  /** Config handed to the planning-role default; omitted uses the user config. */
+  config?: UserConfig;
+}
+
+/**
+ * ROLE-RELAY-SPLIT — the decompose model selector (pure).
+ *
+ * An explicit `model` argument wins; the default is the existing planning-role
+ * resolver `resolveRoleModel('planning')` (env `ELANOUS_SKILL_PLAN_MODEL` ·
+ * `roleLlm.planning` · tier `best` — the same tier the old default used), NOT
+ * the review env `ELANOUS_PR_REVIEW_MODEL`: changing the review model must
+ * not drag the decompose model along.
+ */
+export function decomposeModel(explicit?: string, deps: DecomposeModelDeps = {}): DecomposeModelResolution {
+  const pinned = explicit?.trim();
+  if (pinned) return { model: pinned, source: 'explicit' };
+  const resolved = resolveRoleModel('planning', deps.config);
+  return { model: resolved.model, source: resolved.source };
+}
+
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */
 async function defaultDecomposeLlm(model?: string): Promise<SelfDevDecomposeLlm> {
   const { streamLLM } = await import('../llm.js');
-  const m = model || process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('best');
-  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: m, reasoningEffort: 'low' });
+  const { model: resolved, source } = decomposeModel(model);
+  debug.log('self-dev.decompose', 'model', { model: resolved, source });
+  return (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { model: resolved, reasoningEffort: 'low' });
 }

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

@@ -65,6 +65,7 @@ import { findGrokModel, GROK_MODELS } from '../grok/models.js';
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import { BUILTIN_CATALOG } from '../intelligence-map/model-catalog.js';
 import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrockModelId } from '../llm/bedrock.js';
+import { ZAI_CODING_DEFAULT_MODEL, ZAI_CODING_MODELS } from '../llm/zai-coding-plan.js';
 
 /** `dev --plan` 도움말이 가리키는 대응 문. ⛔ 도움말에 이 문자열을 리터럴로 다시 적지 마라. */
 export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
@@ -1097,6 +1098,9 @@ export async function executeDevSelfRun(
     retainConfirmedMerge(result);
     await superviseRun({
       initial: [initialJob],
+      // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
+      // authored goal as its feature). Without that executor the rerun could only replay the same goal — declare false.
+      repairGoalExecution: supervise.executePiece !== undefined,
       enrich: (results) => hydrateDevGoalCauseObserved(
         hydrateDevDecomposeProposals(results, supervise.readProposals ?? readDecomposeProposals),
       ),
@@ -1157,7 +1161,24 @@ export async function executeDevSelfRun(
           }) + orderingNote,
         };
       },
-      rerun: async (previous, { relaunch }) => {
+      rerun: async (previous, { relaunch, repairGoals }) => {
+        const repairJobs = previous.flatMap((job) => repairGoals?.[job.taskId] === undefined ? [] : [{ job, goal: repairGoals[job.taskId]! }]);
+        if (repairJobs.length > 0 && supervise.executePiece !== undefined) {
+          if (recordRestart('relaunch', previous.at(-1)!)) return [];
+          executedRounds += 1;
+          // Every authored repair goal runs (one per oscillating task), each keeping its task's goal feature so a
+          // second oscillation is recognised as «already repaired».
+          const repaired: ReturnType<typeof asSupervisorJobResult>[] = [];
+          for (const { job, goal } of repairJobs) {
+            try { debug.log('self-dev.supervisor', 'oscillation-repair.executed', { surface: 'dev', taskId: job.taskId, chars: goal.length }); } catch { /* fail-open */ }
+            const repairResult = recordResult(await supervise.executePiece(goal));
+            retainConfirmedMerge(repairResult);
+            if (shardResults === undefined) result = repairResult;
+            repaired.push({ ...asSupervisorJobResult(job.feature, repairResult), oscillationRepairOf: job.taskId });
+          }
+          // Jobs without a repair goal are not dropped: their last result stays in the round for the next decision.
+          return [...repaired, ...previous.filter((job) => repairGoals?.[job.taskId] === undefined)];
+        }
         if (promotedPieces !== undefined) {
           const pieces = promotedPieces;
           promotedPieces = undefined;
@@ -1340,12 +1361,19 @@ export function normalizeChildLlmProvider(provider: string): string {
     : p;
 }
 
+/** CLAUDE-IMPL-LANE — claude-acp = Claude 구독 ACP 구현 레인(src/agent-substrate/acp-implementer.ts). 모델 카탈로그·사다리는 anthropic 과 같다. */
+function childModelCatalogProvider(provider: string): string {
+  const normalized = normalizeChildLlmProvider(provider);
+  return normalized === 'claude-acp' ? 'anthropic' : normalized;
+}
+
 function isKnownChildLlmProvider(provider: string): boolean {
-  return ['grok', 'anthropic', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock'].includes(normalizeChildLlmProvider(provider));
+  // ZAI-POD-CHILD (0.2.24) — glm = Z.ai GLM Coding Plan 직결(`ZAI_API_KEY` · src/llm/zai-coding-plan.ts). Pod 자식이 `--child-llm-provider glm` 으로 뜬다.
+  return ['grok', 'anthropic', 'claude-acp', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock', 'glm'].includes(normalizeChildLlmProvider(provider));
 }
 
 function findPickerCatalogModel(provider: string, id: string): CatalogModelView | undefined {
-  switch (normalizeChildLlmProvider(provider)) {
+  switch (childModelCatalogProvider(provider)) {
     case 'grok': return findGrokModel(id);
     case 'anthropic': return findClaudeModel(id);
     case 'gemini': return findGeminiModel(id);
@@ -1353,12 +1381,15 @@ function findPickerCatalogModel(provider: string, id: string): CatalogModelView
     case 'openai-codex': return findCodexModel(id);
     case 'openrouter': return findOpenRouterChildModel(id);
     case 'bedrock': return findBedrockChildModel(id);
+    case 'glm': return (ZAI_CODING_MODELS as readonly string[]).includes(id)
+      ? { id, tier: /flash/i.test(id) ? 'budget' : 'balanced', supportsThinking: true, recommended: id === ZAI_CODING_DEFAULT_MODEL }
+      : undefined;
     default: return undefined;
   }
 }
 
 /** BEDROCK-PROVIDER — `anthropic.claude-sonnet-5-5` · `bedrock/claude-sonnet-5-5` · (provider=bedrock 일 때) `claude-sonnet-5-5`
- *  를 받아 와이어 id(`anthropic.` 접두)로 해석한다. 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
+ *  를 받아 와이어 id 로 해석한다(5.5 = 전역 추론 프로필 `global.anthropic.…` · BEDROCK-RUNTIME-PATH). 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
 function findBedrockChildModel(id: string): CatalogModelView | undefined {
   const entry = findBedrockModel(id);
   if (!entry) return undefined;
@@ -1394,7 +1425,7 @@ function tierFromBuiltin(tags: readonly string[] | undefined): string {
 }
 
 function findBuiltinCatalogModel(provider: string, id: string): CatalogModelView | undefined {
-  const expected = normalizeChildLlmProvider(provider);
+  const expected = childModelCatalogProvider(provider);
   const entry = BUILTIN_CATALOG.models.find((model) => (
     model.id === id && normalizeChildLlmProvider(model.provider) === expected
   ));
@@ -1408,7 +1439,7 @@ function findBuiltinCatalogModel(provider: string, id: string): CatalogModelView
 }
 
 function listImplementationChildModelCandidates(provider: string): string[] {
-  const expected = normalizeChildLlmProvider(provider);
+  const expected = childModelCatalogProvider(provider);
   const picker = (() => {
     switch (expected) {
       case 'grok': return GROK_MODELS.map((model) => model.id);
@@ -1418,6 +1449,7 @@ function listImplementationChildModelCandidates(provider: string): string[] {
       case 'openai-codex': return CODEX_MODELS.map((model) => model.id);
       case 'openrouter': return [...new Set(MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model))];
       case 'bedrock': return BEDROCK_MODELS.map((model) => model.id);
+      case 'glm': return [...ZAI_CODING_MODELS];
       default: return [];
     }
   })();
@@ -1576,10 +1608,12 @@ export function grokWeeklyUsedPctFromUsageJson(stdout: string): number | undefin
 /** `elanous usage --json` 의 grok 행 → 잔량 판정. 한 행이라도 100% 미만이면 usable, 모두 100% 이상이면 exhausted. */
 export function grokQuotaFromUsageJson(stdout: string): 'usable' | 'exhausted' | 'unknown' {
   try {
-    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; usedPercent?: number | null } }> };
+    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; periodType?: string | null; usedPercent?: unknown } }> };
     const percents = (parsed.rows ?? [])
-      .filter((row) => row.provider === 'grok' && row.credits?.status === 'ok' && typeof row.credits.usedPercent === 'number')
-      .map((row) => row.credits!.usedPercent as number);
+      .filter((row) => row.provider === 'grok' && row.credits?.status === 'ok'
+        && row.credits.periodType === 'USAGE_PERIOD_TYPE_WEEKLY')
+      .map((row) => row.credits?.usedPercent)
+      .filter((pct): pct is number => typeof pct === 'number' && Number.isFinite(pct) && pct >= 0 && pct <= 100);
     if (percents.length === 0) return 'unknown';
     return percents.some((p) => p < 100) ? 'usable' : 'exhausted';
   } catch {
@@ -1722,7 +1756,7 @@ function announceChildLlmInterpretation(
 export const CHILD_LLM_DEFAULT_TIER = 'better' as const;
 
 export function defaultChildLlmModel(provider: string): string {
-  return tierModel(CHILD_LLM_DEFAULT_TIER, provider as never);
+  return tierModel(CHILD_LLM_DEFAULT_TIER, childModelCatalogProvider(provider) as never);
 }
 
 export type ChildLlmConfigSnapshot = { provider?: string; model?: string };

package/src/self-dev/dev-pipeline.ts

@@ -15,7 +15,8 @@
 //   self 는 backend 리스트 항목이 아니라 transport 축을 붕괴시키는 특수 갈래. 감독 축도 self=turn 레벨.
 
 import { execFileSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { benchArmBranchForBase } from '../bench/bench.js';
 import { readFileSync } from 'node:fs';
 import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { getNestDepth } from '../agent/nest-depth.js';
@@ -25,6 +26,7 @@ import { createRepositoryReferencedFileReader, type ReferencedFileReader } from
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
 import { debug } from '../debug/log.js';
+import { REVIEW_DEFERRED_TO_HOST_ENV, reviewDeferredToHostFromEnv } from '../self-implement/review-deferred-to-host.js';
 import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import type { GitRunResult } from '../git-fs/retry.js';
@@ -40,7 +42,7 @@ import type { IngestionEntry } from '../agent-substrate/execution/ingestion-poli
 import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-store.js';
-import { getUserConfig, resolveRoleLlm } from '../user-config.js';
+import { getUserConfig, resolveRoleLlm, type RoleLlmSource } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
 import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
@@ -609,7 +611,11 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.naturalLanguageDispatch ? { naturalLanguageDispatch: true } : {}),
     ...(s.childLlm ? { childLlm: s.childLlm } : {}),
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
-    ...(s.branchName ? { branchName: s.branchName } : {}),
+    // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 팔 가지 `bench/<id>/<arm>` (명시 branchName 이 이긴다).
+    ...(() => {
+      const branchName = s.branchName ?? benchArmBranchForBase(plan.base, s.childLlm?.model, process.env.ELANOUS_RUN_ID?.trim() || randomUUID());
+      return branchName ? { branchName } : {};
+    })(),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),
     launch: resolveLaunchStamp({ entrance: plan.entrance, queueId: process.env.ELANOUS_HARNESS_QUEUE_LAUNCH }),
   };
@@ -1046,16 +1052,29 @@ export function unmannedToolReviewerRateFromConfig(
   return DEFAULT_UNMANNED_TOOL_REVIEWER_RATE;
 }
 
-function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection): void {
+function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection, skipped?: { reason: 'role-pinned'; roleSource: RoleLlmSource }): void {
   try {
     debug.log('self-dev.reviewer', 'tool-reviewer.select', {
       picked: selection.picked,
       rate: selection.rate,
       sample: selection.sample,
+      ...(skipped ? { skipped: skipped.reason, roleSource: skipped.roleSource } : {}),
     });
   } catch { /* fail-soft */ }
 }
 
+/**
+ * TOOL-REVIEWER-ROLE-PIN — a review role pinned for THIS launch (`--role-llm review=…` flag, or the Pod's
+ * `ELANOUS_ROLE_LLM_REVIEW` env pin) is a declaration that every review in the run uses that model; the
+ * unmanned tool-reviewer lottery must not swap it out (10-10 OR probe #25906: the draw picked the ACP
+ * reviewer and skipped the glm-5.3 pin, so bench arms got different reviewers). `environment` also covers the
+ * older `ELANOUS_PR_REVIEW_MODEL` env model pin. Config `roleLlm.review` is a standing default, not a per-launch
+ * pin — it keeps the lottery.
+ */
+export function reviewRolePinnedForLaunch(source: RoleLlmSource): boolean {
+  return source === 'flag' || source === 'environment';
+}
+
 async function defaultMakeUnmannedToolReviewLLM(): Promise<UnmannedToolReviewLLM> {
   const { makeLazyAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');
   return makeLazyAcpReviewLLM({ cwd: process.cwd() });
@@ -1080,6 +1099,8 @@ export async function buildDefaultSelfImplementSeams(
     makeToolReviewLLM?: () => UnmannedToolReviewLLM | Promise<UnmannedToolReviewLLM>;
     subscriptionReviewerDeps?: SubscriptionReviewerDeps;
     makeSubscriptionReviewLLM?: (spawn: ReturnType<typeof import('./review-provider-fallback.js').subscriptionReviewerSpawn>) => (prompt: string) => Promise<string>;
+    /** REVIEW-ACP-POD ②-b 시험 주입 — 기본은 env `ELANOUS_REVIEW_DEFERRED_TO_HOST=1`(발사 호스트가 싣는다). */
+    reviewDeferredToHost?: boolean;
   } = {},
 ): Promise<SelfImplementSeams> {
   const { defaultSeams } = await import('../self-implement/seams.js');
@@ -1134,11 +1155,14 @@ export async function buildDefaultSelfImplementSeams(
   let reviewerCanSelfRead: boolean | undefined;
   if (reviewerIsDefaultApiCall) {
     const rate = parseUnmannedToolReviewerRate(deps.toolReviewerRate) ?? unmannedToolReviewerRateFromConfig();
-    const sample = typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
-      ? deps.toolReviewerSample
-      : (deps.toolReviewerRoll ?? Math.random)();
-    const selection = selectUnmannedToolReviewer(rate, sample);
-    observeUnmannedToolReviewerSelection(selection);
+    const rolePinned = reviewRolePinnedForLaunch(reviewRole.source);
+    const sample = rolePinned
+      ? 1
+      : typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
+        ? deps.toolReviewerSample
+        : (deps.toolReviewerRoll ?? Math.random)();
+    const selection = rolePinned ? { picked: false, rate, sample } : selectUnmannedToolReviewer(rate, sample);
+    observeUnmannedToolReviewerSelection(selection, rolePinned ? { reason: 'role-pinned', roleSource: reviewRole.source } : undefined);
     if (selection.picked) {
       llmReview = await (deps.makeToolReviewLLM ?? defaultMakeUnmannedToolReviewLLM)();
       reviewerCanSelfRead = true;
@@ -1159,6 +1183,11 @@ export async function buildDefaultSelfImplementSeams(
       reviewerCanSelfRead = undefined;
     }
   }
+  // REVIEW-ACP-POD ②-b — 발사 호스트가 Claude ACP 로 리뷰할 때만 실린다. 리뷰 심이 api 리뷰어를 부르지 않는다(판정은 호스트).
+  const reviewDeferredToHost = deps.reviewDeferredToHost ?? reviewDeferredToHostFromEnv(process.env);
+  if (reviewDeferredToHost) {
+    try { debug.log('self-dev.review-fallback', 'review-deferred-to-host', { env: REVIEW_DEFERRED_TO_HOST_ENV, source: deps.reviewDeferredToHost !== undefined ? 'option' : 'env' }); } catch { /* fail-soft */ }
+  }
   const opensPr = plan.completion !== 'worktree-only';
   const target = plan.target === undefined ? undefined : revalidateHarnessTarget(plan.target);
   if (target?.status === 'outside-home') {
@@ -1176,6 +1205,7 @@ export async function buildDefaultSelfImplementSeams(
     ...(plan.self?.activityGraceSec !== undefined ? { implementActivityGraceSec: plan.self.activityGraceSec } : {}),
     llmReview,
     ...(subscriptionReviewLLM ? { subscriptionReviewLLM } : {}),
+    ...(reviewDeferredToHost ? { reviewDeferredToHost: true } : {}),
     ...(reviewerCanSelfRead !== undefined ? { reviewerCanSelfRead } : {}),
     ...(deps.reviewScopeDiff ? { reviewScopeDiff: deps.reviewScopeDiff } : {}),
     onProgress: ({ stage, message }) => {

package/src/self-dev/draft-residue.ts

@@ -7,27 +7,36 @@ import { debug } from '../debug/log.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { appendRunLedgerEntry, listRunLedgers, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { clipRegateDetail, regateFailureFacts, type HostRegateFailure } from '../self-implement/regate-detail.js';
 import { DRAFT_SWEEP_CLOSE_CAP } from './draft-sweep.js';
 import { PROTECTED_LABELS, sameVerifiedGoal, type DraftTriagePr } from './draft-triage-rules.js';
 
-export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved';
+export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved' | 'timed-out-harvestable';
 export interface PrTerminalRecord {
   childRunId: string;
   prNumber: number | null;
   prUrl: string | null;
   repository: string | null;
   headSha: string | null;
+  /** Copied from disposition.branch when present; null when the child did not name a branch. */
+  branch?: string | null;
   terminalClass: PodTerminalClass;
   stage: string | null;
   owner: string;
   ownerSource: 'seat' | 'card' | 'unknown';
   card: string | null;
   at: string;
+  /** Which host-regate gate failed and why — null for every other terminal. */
+  /** HOST-REGATE-REASON-LOST: detail keeps a bounded head ⊕ tail (4KB); pr-head · merge steps add the expected/actual
+   *  head, merge-conflict adds the conflicted files, merge adds the failure kind (race · moved head · conflict · policy). */
+  hostRegateFailure: (HostRegateFailure & { os: string }) | null;
 }
 export interface PodTerminalInput {
   childRunId: string;
   state: 'complete' | 'failed' | 'aborted';
-  disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean } | null;
+  disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean;
+    branch?: string | null;
+    hostRegate?: { passed: boolean; failures: HostRegateFailure[]; os: string } | null } | null;
   env?: Readonly<Record<string, string | undefined>>;
   prBody?: string;
   goalText?: string;
@@ -44,16 +53,28 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const prUrl = typeof d?.prUrl === 'string' ? d.prUrl : null;
   const match = prUrl && /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\/?$/.exec(prUrl);
   const repository = match && Number(match[3]) === prNumber ? `${match[1]}/${match[2]}` : null;
+  const branch = typeof d?.branch === 'string' && d.branch.trim() ? d.branch.trim() : null;
   const card = cardOf(input.prBody) ?? cardOf(input.goalText);
   const seat = input.env?.ELANOUS_HARNESS_SEAT;
   const ownerSource = seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? 'seat' : card ? 'card' : 'unknown';
+  const hostRegate = d?.hostRegate;
+  const firstFailure = hostRegate?.passed === false && Array.isArray(hostRegate.failures) ? hostRegate.failures[0] : undefined;
+  const hostRegateFailure = d?.stage === 'host-regate-failed' && hostRegate?.passed === false
+    ? { step: typeof firstFailure?.step === 'string' && firstFailure.step ? firstFailure.step : 'unknown',
+      detail: typeof firstFailure?.detail === 'string' && firstFailure.detail
+        ? clipRegateDetail(firstFailure.detail.split(/\s+/).filter(Boolean).join(' '))
+        : 'failures empty',
+      ...regateFailureFacts(firstFailure),
+      os: hostRegate.os }
+    : null;
   return {
-    childRunId: input.childRunId, prNumber, prUrl, repository,
+    childRunId: input.childRunId, prNumber, prUrl, repository, branch,
     headSha: typeof d?.checkedHeadCommit === 'string' && /^[a-f0-9]{40}$/i.test(d.checkedHeadCommit) ? d.checkedHeadCommit : null,
     terminalClass: !d ? 'failed-pr-unobserved' : d.merged === true ? 'landed'
+      : prNumber === null && d.stage === 'timed-out' && branch ? 'timed-out-harvestable'
       : prNumber === null ? 'failed-no-pr'
         : input.state === 'complete' && d.ok !== false ? 'merge-ready-not-merged' : 'failed-with-pr',
-    stage: d?.stage ?? null,
+    stage: d?.stage ?? null, hostRegateFailure,
     owner: ownerSource === 'seat' ? seat! : ownerSource === 'card' ? card! : 'unknown',
     ownerSource, card, at: input.at ?? new Date().toISOString(),
   };
@@ -270,7 +291,7 @@ export async function replayPodTerminals(options: DraftResidueReplayOptions = {}
     for (const terminal of terminals) {
       const record = terminal.data as unknown as PrTerminalRecord;
       if (typeof record.childRunId !== 'string' || typeof record.owner !== 'string'
-        || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved'].includes(record.terminalClass)
+          || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved', 'timed-out-harvestable'].includes(record.terminalClass)
         || (record.prNumber !== null && (!Number.isSafeInteger(record.prNumber) || record.prNumber <= 0))
         || (record.repository !== null && (typeof record.repository !== 'string' || !/^[\w.-]+\/[\w.-]+$/.test(record.repository)))) {
         throw new Error(`Invalid terminal record: ${ledgerRunId}`);
@@ -326,6 +347,7 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
       adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal', data: { ...record } }, ctx.ledgerDir);
       log('terminal-recorded');
     }
+    // AUT-TIMEOUT-NO-HARVEST 첫 조각은 «분류만» — 그 branch 로 PR 을 여는 효과는 다음 조각(원격 가지 존재·기존 PR 확인 관문과 함께).
     if (record.terminalClass === 'failed-no-pr' || record.terminalClass === 'failed-pr-unobserved' || record.prNumber === null) {
       acknowledge('complete', 0);
       return skipped(record.terminalClass);