elanous 0.2.22 → 0.2.24

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';
@@ -29,6 +31,7 @@ import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { readSchedules, releasedVersion } from '../release-loop/feature-store.js';
 import { runOpDecide, type OpDecideCandidate } from './op-decide.js';
+import { readHandedCells, readTrafficSignal, type TrafficSignalRead } from './traffic-signal.js';
 
 // `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
 export type SeatItem = { source: 'request' | 'checklist' | 'hook' | 'seat-question' | 'idle'; kind?: 'request' | 'cell' | 'hook-task' | 'seat-question'; id: string; title: string; text: string; evidence?: string; status?: string; version?: string; seat?: string; evidenceHash?: string; asOf?: string; queuedAt?: string; createdAt?: string; from?: SeatId; idleRung?: 1 | 2 | 3 | 4 | 5 };
@@ -71,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>;
@@ -81,6 +86,9 @@ export type SeatDeps = {
   schedules?: () => Array<{ version: string; cutAt: string; landBy?: string | null }>;
   /** Checklist items of one version — default reads the release ledger DB (checklist.json is only a legacy import source since REL5b). */
   checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string }>;
+  /** Optional injected traffic/handoff snapshots; defaults read the OP files. */
+  trafficSignal?: TrafficSignalRead;
+  handedCells?: ReadonlySet<string>;
   /** Chronological release-ledger events for a checklist id; injected for isolated release fixtures. */
   checklistHistory?: (id: string) => ReturnType<typeof checklistHistory>;
   /** Full checklist snapshot including history, for stall detection. */
@@ -114,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;
@@ -526,11 +551,31 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
   }
   const checklist: SeatItem[] = [];
   const closed: string[] = [];
-  for (const version of open === null ? [] : versions().sort(versionOrder)) {
+  // runSeatLoopOnce → gatherSeatInputs → pickNext: only checklist construction is gated;
+  // requests, hook cards and seat questions above keep their original selection path.
+  const signal = deps.trafficSignal === undefined ? readTrafficSignal() : deps.trafficSignal;
+  // The signal verdict comes first; the handed ledger is read only when the signal would let cells through,
+  // so a handed read failure never masks `signal-not-green` / `signal-seat-paused`.
+  let handed: ReadonlySet<string> = new Set();
+  let handedUnreadable = false;
+  const signalStops = signal !== null && ('unreadable' in signal || signal.global !== 'green' || Boolean(signal.paused?.[seat]));
+  if (signal !== null && !signalStops) {
+    try { handed = deps.handedCells ?? readHandedCells(); }
+    catch { handedUnreadable = true; }
+  }
+  if (signal !== null && 'unreadable' in signal) debug.log('seat.loop', 'signal-unreadable', { seat });
+  else if (signal !== null && signal.global !== 'green') debug.log('seat.loop', 'signal-not-green', { seat });
+  else if (signal !== null && signal.paused?.[seat]) debug.log('seat.loop', 'signal-seat-paused', { seat });
+  else if (handedUnreadable) debug.log('seat.loop', 'signal-unreadable', { seat, source: 'handed' });
+  else for (const version of open === null ? [] : versions().sort(versionOrder)) {
     if (!open!.has(version)) {
       closed.push(version);
       continue;
     }
+    if (signal?.versions && !signal.versions.includes(version)) {
+      debug.log('seat.loop', 'skip-signal-version', { version });
+      continue;
+    }
     let items: ReturnType<typeof itemsOf>;
     try { items = itemsOf(version); } catch (error) {
       debug.log('seat.loop', 'checklist-unreadable', { seat, version, error: String(error).slice(0, 200) });
@@ -543,6 +588,14 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
     }
     for (const item of items) {
       if (item.owner === seat && (item.status === 'yellow' || item.status === 'red')) {
+        if (signal?.hold?.includes(item.id)) {
+          debug.log('seat.loop', 'skip-signal-cell', { id: item.id, why: 'hold' });
+          continue;
+        }
+        if (handed.has(item.id)) {
+          debug.log('seat.loop', 'skip-signal-cell', { id: item.id, why: 'handed' });
+          continue;
+        }
         checklist.push({ source: 'checklist', kind: 'cell', version, seat, asOf, id: item.id, title: item.title, text: item.title, status: item.status,
           ...(item.evidence ? { evidence: item.evidence } : {}), evidenceHash: createHash('sha256').update(item.evidence ?? '').digest('hex') });
       }
@@ -1171,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);
@@ -1244,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=보류:진행하지 않음',
@@ -1281,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;
@@ -1389,6 +1444,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   const failedDecisions = new Set<string>();
   let lastDecisionFailure: SeatEntry | undefined;
   while (true) {
+  // The seat turn reads the signal-gated checklist and ungated requests before pickNext.
   const inputs = await gatherSeatInputs(seat, deps, ledger);
   inputs.requests = inputs.requests.filter((candidate) => !failedDecisions.has(itemKey(candidate)));
   inputs.checklist = inputs.checklist.filter((candidate) => !failedDecisions.has(itemKey(candidate)));
@@ -1439,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;
@@ -1458,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');
@@ -1559,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=보류:진행하지 않음',
@@ -1623,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/seat-loop/traffic-signal.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export type TrafficSignal = {
+  global: string;
+  versions?: string[];
+  hold?: string[];
+  paused?: Record<string, boolean>;
+};
+export type TrafficSignalRead = TrafficSignal | { unreadable: true } | null;
+
+const defaultPath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
+const missing = (error: unknown): boolean => (error as NodeJS.ErrnoException).code === 'ENOENT';
+
+/** A missing installation has no signal; an invalid or unreadable one cannot authorize a checklist launch. */
+export function readTrafficSignal(path?: string): TrafficSignalRead {
+  try {
+    const value: unknown = JSON.parse(readFileSync(path ?? process.env.ELANOUS_TRAFFIC_SIGNAL ?? defaultPath('traffic.json'), 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return { unreadable: true };
+    const row = value as Record<string, unknown>;
+    if (typeof row.global !== 'string'
+      || (row.versions !== undefined && (!Array.isArray(row.versions) || !row.versions.every((version) => typeof version === 'string')))
+      || (row.hold !== undefined && (!Array.isArray(row.hold) || !row.hold.every((id) => typeof id === 'string')))
+      || (row.paused !== undefined && (!row.paused || typeof row.paused !== 'object' || Array.isArray(row.paused)
+        || !Object.values(row.paused).every((paused) => typeof paused === 'boolean')))) return { unreadable: true };
+    return { global: row.global, ...(row.versions !== undefined ? { versions: row.versions as string[] } : {}),
+      ...(row.hold !== undefined ? { hold: row.hold as string[] } : {}),
+      ...(row.paused !== undefined ? { paused: row.paused as Record<string, boolean> } : {}) };
+  } catch (error) {
+    return missing(error) ? null : { unreadable: true };
+  }
+}
+
+/** A missing handoff ledger has no handed cells; other read errors propagate so selection can fail closed. */
+export function readHandedCells(path?: string): Set<string> {
+  try {
+    return new Set(readFileSync(path ?? process.env.ELANOUS_HANDED_CELLS ?? defaultPath(join('feeder', 'handed.txt')), 'utf8')
+      .split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+  } catch (error) {
+    if (missing(error)) return new Set();
+    throw error;
+  }
+}

package/src/self-dev/ask-launch-flow.ts

@@ -215,7 +215,7 @@ export type AskLaunchFlowResult =
   /** ⓪ 저작 «전»에 막혔다 — 100초를 안 썼다. */
   | { readonly kind: 'stopped-before-authoring'; readonly goalFile?: undefined }
   /** ⑵⑶⑷ 에서 막혔다 — 골은 «있다»(사람이 열어볼 수 있게 돌려준다). */
-  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string };
+  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] };
 
 /** 런 식별자가 흐름 뒤에 확정된 호출자는 이 관측으로 입구와 런을 조인한다. */
 export function observeAskLaunchRunIdentity(
@@ -1103,5 +1103,5 @@ export async function runAskLaunchFlow(
   }
   return launchDecision
     ? { kind: 'launch', goalFile: effectiveGoalFile }
-    : { kind: 'stopped-by-preflight', goalFile: effectiveGoalFile };
+    : { kind: 'stopped-by-preflight', goalFile: effectiveGoalFile, blockers: preflight.blockers };
 }

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

@@ -30,7 +30,8 @@ import type { ReasoningEffortCeiling } from '../intelligence-map/model-catalog.j
 import { tierModel } from '../llm/model-defaults.js';
 import { LLM_TIER_MAP_BY_PROVIDER } from '../model-tier/llm-tier-map.js';
 import { MODEL_TIERS } from '../model-tier/types.js';
-import { getCatalog } from '../registry/loader.js';
+import { getCatalog, isolatedCatalogTestUniverse } from '../registry/loader.js';
+import { isLiveVerifiedOpenRouterModel, liveLookupOpenRouterModel, OPENROUTER_SNAPSHOT_STALE_DAYS, readFoldSnapshotAgeDays, upstreamOpenRouterId } from '../registry/discovery/openrouter-live-resolve.js';
 import { singleRunAsJobResult } from '../self-implement/self-implement-cli.js';
 import { superviseRun, type SupervisorDecision, type SupervisorStopReason } from './run-supervisor.js';
 import { readDecomposeProposals, orderPiecesTopologically } from './decompose-proposal.js';
@@ -63,6 +64,8 @@ import { findGeminiModel, GEMINI_MODELS } from '../gemini/models.js';
 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';
@@ -1095,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),
       ),
@@ -1155,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;
@@ -1338,28 +1361,49 @@ 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'].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);
     case 'openai':
     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 로 해석한다(5.5 = 전역 추론 프로필 `global.anthropic.…` · BEDROCK-RUNTIME-PATH). 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
+function findBedrockChildModel(id: string): CatalogModelView | undefined {
+  const entry = findBedrockModel(id);
+  if (!entry) return undefined;
+  // 지역 접두(`us.anthropic.…`)를 줬으면 그 와이어 id 를 그대로 쓴다(데이터 거주 선택 보존).
+  return { id: resolveBedrockModelId(id), tier: entry.tier, supportsThinking: entry.supportsThinking, recommended: entry.id === BEDROCK_DEFAULT_MODEL };
+}
+
 /** 결정 2026-09-23 — openrouter 는 피커 목록이 없다(454개 게이트웨이). 받는 것 = ⑴ openrouter 사다리의 모델
  *  ⊕ ⑵ 카탈로그 폴드에 있는 `openrouter/*`(운영 스냅숏이 갱신됐을 때). 둘 다 아니면 «모른다» → 거부. */
 function findOpenRouterChildModel(id: string): CatalogModelView | undefined {
   const ladder = MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model);
   const folded = getCatalog().models.get(id);
-  if (!ladder.includes(id) && folded?.provider !== 'openrouter') return undefined;
+  if (!ladder.includes(id) && folded?.provider !== 'openrouter' && !isLiveVerifiedOpenRouterModel(id)
+    && !(isolatedCatalogTestUniverse() && !process.env.ELANOUS_CATALOG_DISCOVERY_SNAPSHOT?.trim() && /^openrouter\/[^/\s]+\/[^/\s]+$/.test(id))) return undefined;
   return {
     id,
     tier: id === LLM_TIER_MAP_BY_PROVIDER.openrouter.balanced.model ? 'balanced' : 'standard',
@@ -1381,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
   ));
@@ -1395,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);
@@ -1404,6 +1448,8 @@ function listImplementationChildModelCandidates(provider: string): string[] {
       case 'openai':
       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 [];
     }
   })();
@@ -1444,6 +1490,56 @@ export function resolveImplementationChildModel(provider: string, model: string)
   };
 }
 
+let staleOpenRouterSnapshotWarned = false;
+
+/** OR-MODEL-NAMESPACE — 발사 «전» 비동기 관문. 동기 해석(`resolveImplementationChildModel`)이 스냅숏 밖의
+ *  `openrouter/<vendor>/<model>` 을 거부할 때만 공개 `/models` 를 한 번 묻는다.
+ *  ⛔ openrouter 가 아닌 provider · 스냅숏에 이미 있는 id 는 네트워크 0 · 해석 결과 불변.
+ *  ⛔ 확인 못 함(네트워크·시간 초과·봉투 오류)은 거부(fail-closed) ⊕ 사유 «카탈로그 확인 못 함». */
+export async function ensureOpenRouterChildModelLive(
+  provider: string | undefined,
+  model: string | undefined,
+  deps: { fetchImpl?: typeof fetch; timeoutMs?: number; write?: (line: string) => void; now?: () => number; persist?: boolean } = {},
+): Promise<void> {
+  if (!provider?.trim() || !model?.trim()) return;
+  if (normalizeChildLlmProvider(provider) !== 'openrouter') return;
+  const write = deps.write ?? ((line: string) => process.stderr.write(line));
+  const ageDays = readFoldSnapshotAgeDays((deps.now ?? Date.now)());
+  if (ageDays !== undefined && ageDays > OPENROUTER_SNAPSHOT_STALE_DAYS && !staleOpenRouterSnapshotWarned) {
+    staleOpenRouterSnapshotWarned = true;
+    write(`[dev] ⚠️ OpenRouter 모델 스냅숏이 ${ageDays}일 묵었다(discovery-snapshot.json) — 없는 모델은 공개 카탈로그로 한 번 확인한다\n`);
+  }
+  try {
+    resolveImplementationChildModel(provider, model);
+    return;
+  } catch (err) {
+    const entered = model.trim();
+    const aliased = resolveModelAlias(entered) ?? entered;
+    if (!upstreamOpenRouterId(aliased)) throw err;
+    const lookup = await liveLookupOpenRouterModel(aliased, {
+      ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+      ...(deps.timeoutMs !== undefined ? { timeoutMs: deps.timeoutMs } : {}),
+      ...(deps.now ? { now: deps.now } : {}),
+      ...(deps.persist !== undefined ? { persist: deps.persist } : {}),
+    });
+    if (lookup.found) {
+      if (!lookup.persisted && deps.persist !== false) {
+        write(`[dev] ⚠️ ${aliased} 은 OpenRouter 에서 확인했지만 스냅숏에 못 합쳤다 — 이 프로세스에서만 통과(자식·Pod 재해석은 거부될 수 있다)\n`);
+      }
+      resolveImplementationChildModel(provider, model);
+      return;
+    }
+    if (lookup.error) {
+      throw new DevPipelineError(`${err instanceof Error ? err.message : String(err)} · 카탈로그 확인 못 함(${lookup.error})`);
+    }
+    throw err;
+  }
+}
+
+export function __resetStaleOpenRouterSnapshotWarningForTests(): void {
+  staleOpenRouterSnapshotWarned = false;
+}
+
 export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
 
 export function childLlmEffortCeiling(_provider: string, model: string): ReasoningEffortCeiling {
@@ -1512,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 {
@@ -1658,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';
@@ -44,7 +45,7 @@ import { getUserConfig, resolveRoleLlm } 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';
-import { loadLlmPolicy } from '../policy/llm-policy.js';
+import { loadLlmPolicy, resolveSubscriptionReviewer } from '../policy/llm-policy.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
 import { harnessTargetOptions, resolveHarnessTarget, revalidateHarnessTarget, type HarnessTargetResolution } from '../self-implement/harness-target-options.js';
 import { provisionRepository, type RepoProvisionResult } from '../self-implement/repo-provision.js';
@@ -609,7 +610,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 }),
   };
@@ -1148,11 +1153,9 @@ export async function buildDefaultSelfImplementSeams(
   }
   let subscriptionReviewLLM: ((prompt: string) => Promise<string>) | undefined;
   if (reviewerIsDefaultApiCall) {
-    const userConfig = getUserConfig();
-    const policy = loadLlmPolicy();
-    const spec = policy.policy.roles.reviewer ?? userConfig.roleLlm?.reviewer;
-    if (spec) {
-      const cap = policy.policy.caps.claude.harness;
+    const reviewer = resolveSubscriptionReviewer(loadLlmPolicy(), getUserConfig().roleLlm);
+    if (reviewer) {
+      const { spec, cap } = reviewer;
       subscriptionReviewLLM = (prompt) => runSubscriptionReviewer(spec, cap, prompt, defaultApiReview, async (text, spawn) => {
         if (deps.makeSubscriptionReviewLLM) return deps.makeSubscriptionReviewLLM(spawn)(text);
         const { makeAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');