elanous 0.2.36 → 0.2.37

package/src/model-tier/llm-tier-map.ts

@@ -431,23 +431,17 @@ const OPENGATEWAY: TierMap = {
 };
 
 // ── AWS Bedrock (BEDROCK-PROVIDER · 2026-10-11) ───────────────────
-//   ⭐ 판단: ANTHROPIC 사다리의 «추론 수준·역할 배치»를 그대로 두고, 모델은 Bedrock 메시지 엔드포인트에서
-//   확인한 5.5 계열 id(`src/llm/bedrock.ts` BEDROCK_MODELS · 출처 platform.claude.com «Claude in Amazon Bedrock»
-//   Supported models)로만 채운다. 아래 칸(budget·balanced)은 ANTHROPIC 이 haiku-4-5·sonnet-5 를 쓰지만, 이 PR 이
-//   카탈로그에 올린 Bedrock id 는 5.5 셋뿐이라 같은 등급의 5.5(haiku-5-5·sonnet-5-5)로 올렸다.
 //   ⛔ bedrock 은 명시 선택 전용 — 이 표는 `--role-llm <role>=bedrock/<tier>` 같은 «명시» 해석에만 쓰인다.
-//   ⚠️ status = `wip`: 실 AWS 호출(계정별 5.5 접근 조건)을 아직 안 쟀고, 셋업 키 감지 표(PROVIDER_ENV_SPEC)에도
-//      없다(자격이 API 키가 아니라 AWS 체인이라). 첫 실호출 스모크 뒤 `shipping` 으로 올린다.
-//   ⭐ BEDROCK-RUNTIME-PATH(10-11): 메시지 엔드포인트(mantle)에 5.5 가 없어(📏 `GET /v1/models`) 사다리 id 를 전역 추론 프로필
-//      `global.anthropic.…`(runtime 경로 · bedrock.ts BEDROCK_MODELS 의 `route` 칸)로 옮겼다. 공급자 이름은 그대로 `bedrock`.
-//      📏 budget·balanced(haiku/sonnet 5.5)는 runtime 실호출 200 실측(ap-northeast-2) · opus 5.5 는 «추론 프로필 목록에 있음»까지만(호출 0).
-//      status 는 그대로 `wip` — `shipping` 은 셋업 키 감지 표(PROVIDER_ENV_SPEC) 칸을 요구한다(provider-wiring-contract 시험 · 범위 밖).
+//   ⚠️ status = `wip`: mantle-openai 모델의 실제 호출 가능성은 계정별 IAM 접근 조건을 따르며,
+//      셋업 키 감지 표(PROVIDER_ENV_SPEC)에도 없다(자격이 API 키가 아니라 AWS 체인이라).
+//   runtime Converse 모델(GLM 5.3·Kimi K3·Grok 4.7)은 OP/IAM 확인 뒤 별도 추가한다.
+//   ⛔ 아래 비-Anthropic id 들은 `src/llm/bedrock.ts` BEDROCK_MODELS 에 등록된 mantle-openai 행만 사용한다.
 const BEDROCK: TierMap = {
-  budget:   { model: 'global.anthropic.claude-haiku-5-5',  reasoningLevel: 'off',    label: 'Claude Haiku 5.5 (Bedrock)',  rationale: 'Fast · cheap · bulk/classification', status: 'wip' },
-  balanced: { model: 'global.anthropic.claude-sonnet-5-5', reasoningLevel: 'off',    label: 'Claude Sonnet 5.5 (Bedrock)', rationale: 'Default · everyday coding (BEDROCK_DEFAULT_MODEL)', status: 'wip' },
-  better:   { model: 'global.anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'ANTHROPIC better 와 같은 배치(구현 = Opus 5.5)', status: 'wip' },
-  best:     { model: 'global.anthropic.claude-opus-5-5',   reasoningLevel: 'medium', label: 'Claude Opus 5.5 · thinking medium (Bedrock)', rationale: 'Best reasoning · architecture', status: 'wip' },
-  loaded:   { model: 'global.anthropic.claude-opus-5-5',   reasoningLevel: 'high',   label: 'Claude Opus 5.5 · extended thinking (Bedrock)', rationale: 'Loaded · deep multi-step', status: 'wip' },
+  budget:   { model: 'zai.glm-4.7-flash',         reasoningLevel: 'off',    label: 'GLM 4.7 Flash (Bedrock)', rationale: 'Fast · cheap · bulk/classification', status: 'wip' },
+  balanced: { model: 'openai.gpt-6-luna',         reasoningLevel: 'off',    label: 'GPT-6 Luna (Bedrock)', rationale: 'Default · balanced Bedrock mantle-openai model', status: 'wip' },
+  better:   { model: 'deepseek.v3.2',             reasoningLevel: 'medium', label: 'DeepSeek V3.2 (Bedrock)', rationale: 'Higher quality · mantle-openai', status: 'wip' },
+  best:     { model: 'zai.glm-5',                 reasoningLevel: 'medium', label: 'GLM 5 (Bedrock)', rationale: 'Best reasoning · mantle-openai', status: 'wip' },
+  loaded:   { model: 'openai.gpt-6-sol',          reasoningLevel: 'high',   label: 'GPT-6 Sol (Bedrock)', rationale: 'Loaded · deep multi-step · mantle-openai', status: 'wip' },
 };
 
 /** 가격·창 미측정이라 기존 tier 배치를 바꾸지 않고 명시 모델로만 고르는 칸.
@@ -523,8 +517,9 @@ export function lookupOpenRouterModelSpec(model: string): LlmTierSpec | undefine
  *  `auto` and unknown providers have no concrete provider ladder, so both use
  *  Anthropic's balanced default instead of crossing into the Codex family.
  *  Existing execution path: src/llm/model-defaults.ts tierModel() calls this
- *  function to fill the active provider's model at runtime. Explicit providers
- *  keep their own ladders; CLI catalog commands reject unknown/'auto' directly. */
+ *  function (`lookupLlmTierSpec(activeProviderForDefaults(provider), tier)`) to
+ *  fill the active provider's model at runtime. Explicit providers keep their
+ *  own ladders; CLI catalog commands reject unknown/'auto' directly. */
 export function lookupLlmTierSpec(
   provider: LLMProviderName,
   tier: ModelTier,

package/src/msg/msg-store.ts

@@ -278,6 +278,23 @@ export class MsgStore {
       : []);
   }
 
+  /** A request and its direct replies, in insertion order, independent of recipient cursors. */
+  listThread(messageId: number, after: number = 0, limit: number = 100): Message[] {
+    if (!Number.isSafeInteger(messageId) || messageId < 1) throw new Error('message ID must be a positive integer');
+    validCursor(after);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000) throw new Error('limit must be between 1 and 1000');
+    return this.readWithSchema(hasReplyTo => {
+      const target = this.db.query(`SELECT id, ${hasReplyTo ? 'reply_to' : 'NULL AS reply_to'} FROM msg_messages WHERE id = ?`)
+        .get(messageId) as { id: number; reply_to: number | null } | null;
+      if (target === null) throw new Error(`message not found: #${messageId}`);
+      const rootId = target.reply_to ?? target.id;
+      const rows = this.db.query(`SELECT id, sender, recipient, body, kind, ${hasReplyTo ? 'reply_to' : 'NULL AS reply_to'}, created_at FROM msg_messages
+        WHERE id > ? AND (id = ? ${hasReplyTo ? 'OR reply_to = ?' : ''}) ORDER BY id ASC LIMIT ?`)
+        .all(...(hasReplyTo ? [after, rootId, rootId, limit] : [after, rootId, limit])) as MessageRow[];
+      return rows.map(fromRow);
+    });
+  }
+
   list(recipient: string, after: number = 0, limit: number = 100): Message[] {
     return this.listByRecipient(recipient, after, limit);
   }

package/src/native-tool-catalog.ts

@@ -7,7 +7,7 @@
 
 import type { VerifierSpec } from './verifier/types.js';
 import type { GuardianSpec } from './guardian/types.js';
-import { ptyAvailable } from './pty-shell/registry.js';
+import { ptyAvailable } from './pty-shell/availability.js';
 import { krFlowAvailable } from './skills/tools/kr-flow.js';
 import { SELF_COGNITION_MCP_CATALOG_ENTRIES } from './tool-runtime/self-cognition-catalog.js';
 import { SKILLS_LIST_DESCRIPTION } from './onboarding/entry-hints.js';

package/src/nexus/api/graph-wizard-api.ts

@@ -2,6 +2,7 @@ import { debug } from '../../debug/log.js';
 import { GraphWizardInputError, designGraphVariantPlan, generateGraphFromPrompt, wizardInstalledPacks, type GraphWizardDeps, type GraphWizardTurn } from '../../graph-wizard/generate.js';
 import { defaultGraphsDir } from '../../self-implement/graph-templates.js';
 import { loadGraphTemplates } from '../../self-implement/graph-yaml.js';
+import type { NexusEventBus } from './event-bus.js';
 import { jsonResponse } from './json-response.js';
 
 export function handleGraphWizardPacksGet(deps: GraphWizardDeps = {}): Response {
@@ -11,6 +12,28 @@ export function handleGraphWizardPacksGet(deps: GraphWizardDeps = {}): Response
 const MAX_PROMPT = 4000;
 const MAX_YAML = 200_000;
 
+/** 호출 경계에서 variant 한 턴의 결말을 버스에 남긴다 — mode·reason ⊕ 조작 growth 좌표. */
+function publishGraphCompose(eventBus: NexusEventBus | undefined, input: {
+  readonly result: Awaited<ReturnType<typeof designGraphVariantPlan>>;
+  readonly goal: string;
+  readonly templateId: string;
+}): void {
+  const { result, goal, templateId } = input;
+  eventBus?.publish({
+    ts: Date.now(),
+    kind: 'graph.compose',
+    detail: {
+      mode: result.mode,
+      status: result.status,
+      reason: result.reason,
+      goal,
+      templateId,
+      ...(result.growth ? { growth: result.growth } : {}),
+      ...(result.status === 'composed' ? { overlayId: result.variant.overlay.overlayId, patches: result.variant.patches.length } : {}),
+    },
+  });
+}
+
 /**
  * POST /v1/graphs/wizard {prompt, kind?, currentYaml?, history?} or
  * {mode:'variant', prompt, goal, templateId} for one validated L2 plan (no YAML generation).
@@ -18,8 +41,9 @@ const MAX_YAML = 200_000;
  * (labels·steps·recipes·dryRun·baseReason 는 v2 추가 필드 — 기존 필드는 그대로.)
  * currentYaml 이 빈 문자열이면 «빈 캔버스»로 보고 새 그래프를 짓는다(의도) · 내용이 있는데 id 가 없거나 형식 밖이면 400.
  * 저장하지 않는다 — 저장은 POST /v1/graphs(새 그래프) 또는 PUT /v1/graphs/<id>/yaml(내 그래프).
+ * variant 요청은 결말(mode·reason·조작 growth)을 주입된 버스에 `graph.compose` 이벤트로 남긴다.
  */
-export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps = {}): Promise<Response> {
+export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps = {}, eventBus?: NexusEventBus): Promise<Response> {
   let body: Record<string, unknown>;
   try {
     const parsed: unknown = await req.json();
@@ -60,7 +84,8 @@ export async function handleGraphWizardPost(req: Request, deps: GraphWizardDeps
       const template = loadGraphTemplates(deps.graphsDir ?? defaultGraphsDir()).templates[body.templateId];
       if (!template) return jsonResponse({ error: 'bad_request', reason: `unknown templateId: ${body.templateId}` }, 400);
       const result = await designGraphVariantPlan({ goal: body.goal, prompt, template }, deps);
-      return jsonResponse({ mode: 'variant', ...result });
+      publishGraphCompose(eventBus, { result, goal: body.goal, templateId: body.templateId });
+      return jsonResponse(result);
     }
     const result = await generateGraphFromPrompt({
       prompt,

package/src/nexus/api/grid.ts

@@ -1,13 +1,17 @@
 import { getUserConfig } from '../../user-config.js';
 import { readHqLease, type HqDeps } from '../../hq/hq.js';
-import { measurePoolLease, type PoolLeaseMeasure } from '../../task-orchestrator/surfaces/pod-lease.js';
+import { measurePoolLease, type PoolLeaseMeasure, type PodLeaseMember } from '../../task-orchestrator/surfaces/pod-lease.js';
 import { parsePodPool, resolvePodPoolSpec, type PodPoolMember, type PoolKubectl } from '../../task-orchestrator/surfaces/pod-pool.js';
+import type { GateReservation } from '../../ops/overview.js';
 
 export interface GridData {
   /** null means the arbiter could not be read, not that no lease exists. */
   hq: { record: ReturnType<typeof readHqLease>['record']; ageSeconds: number | null; expired: boolean | null; reason: string | null };
-  /** Configured member order; capacity comes from measurePoolLease when available. occupied is running + pending, or null on measurement failure. */
-  members: Array<{ context: string; capacity: number; running: number | null; pending: number | null; occupied: number | null; reason: string | null }>;
+  /**
+   * Configured member order; capacity comes from measurePoolLease when available. occupied is running + pending, or null on measurement failure.
+   * `gate` is GATE-RESERVE-AUTO's reservation for this member — absent when the job/cpu reading failed (unmeasured, not «no gate»).
+   */
+  members: Array<{ context: string; capacity: number; running: number | null; pending: number | null; occupied: number | null; reason: string | null; gate?: GateReservation }>;
   poolReason: string | null;
 }
 
@@ -20,6 +24,21 @@ export interface GridDeps {
   measure?: (members: readonly PodPoolMember[]) => PoolLeaseMeasure;
 }
 
+/**
+ * GATE-RESERVE-AUTO 의 예약 몫을 자원 지도 축 꼴로 옮긴다. Job/CPU 읽기가 실패한 멤버는 undefined 다 —
+ * «게이트 없음»이 아니라 «못 잼»이므로 구속 조건 후보에서 빠진다(0 으로도 무한으로도 읽지 않는다).
+ * 게이트가 안 도는 멤버(jobs 0)는 값으로 남는다: 축은 «게이트 없음»이라고 말할 수 있어야 한다.
+ */
+function gateOf(row: PodLeaseMember | undefined): GateReservation | undefined {
+  if (!row || typeof row.gateJobs !== 'number') return undefined;
+  return {
+    jobs: row.gateJobs,
+    unbound: typeof row.gateUnboundJobs === 'number' ? row.gateUnboundJobs : Number.NaN,
+    reservedMillicores: typeof row.gateCpuMillicores === 'number' ? row.gateCpuMillicores : Number.NaN,
+    schedulableMillicores: typeof row.schedulableCpuMillicores === 'number' ? row.schedulableCpuMillicores : Number.NaN,
+  };
+}
+
 /** Independent, fail-soft read snapshots. No lease status/heartbeat, DNS probe Pod, host reservation or writes. */
 export function buildGridData(deps: GridDeps = {}): GridData {
   let hq: GridData['hq'];
@@ -45,9 +64,10 @@ export function buildGridData(deps: GridDeps = {}): GridData {
           const row = byContext.get(member.context);
           const running = row?.running ?? null;
           const pending = row?.pending ?? null;
+          const gate = gateOf(row);
           return { context: member.context, capacity: row?.capacity ?? member.capacity, running, pending,
             occupied: running === null || pending === null ? null : running + pending,
-            reason: row?.reason ?? (row ? null : '측정 불가') };
+            reason: row?.reason ?? (row ? null : '측정 불가'), ...(gate ? { gate } : {}) };
         });
       } catch (error) {
         poolReason = String(error);

package/src/nexus/api/http-server.ts

@@ -1523,7 +1523,7 @@ export async function routeRequest(
   if (method === 'POST' && pathname === '/v1/graphs/wizard') {
     if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
     if (!checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-    return handleGraphWizardPost(req, opts.graphWizard);
+    return handleGraphWizardPost(req, opts.graphWizard, opts.eventBus);
   }
 
   if (pathname === '/v1/fabric/decompose' || pathname.startsWith('/v1/fabric/plans/')) {

package/src/nexus/api/ops-api.ts

@@ -11,6 +11,7 @@ import { createSeatsCache, todayKst } from './ops-seats.js';
 import { liveSeatsSources } from './ops-seats-sources.js';
 import { createOverviewCache } from '../../ops/overview-cache.js';
 import { resourcesFromOverview } from '../../ops/resources.js';
+import { loopsMapFromCache } from '../../ops/loops-map.js';
 import { parseSince } from '../../ops/overview-collect.js';
 import type { MetaApiOpts } from './meta-api.js';
 
@@ -184,6 +185,14 @@ export function readReleaseRuns(version: string | null = null,
   }).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, 20);
 }
 
+/**
+ * 요청이 «자격을 하나라도 실어 왔는가» — operatorSignal 이 판정에 쓰는 축(베어러·프록시 헤더·쿠키)만 본다.
+ * 아무것도 없으면 401(인증 없음), 있는데 운영자가 아니면 403(권한 없음)으로 가른다.
+ */
+function offeredCredential(req: Request): boolean {
+  return Boolean(req.headers.get('authorization') || req.headers.get('x-elanous-operator') || req.headers.get('cookie'));
+}
+
 /** The sole data gate for every read-only /v1/ops endpoint. */
 export function handleOpsApi(req: Request, metaApi: MetaApiOpts | undefined): Response | Promise<Response> {
   const url = new URL(req.url);
@@ -195,6 +204,9 @@ export function handleOpsApi(req: Request, metaApi: MetaApiOpts | undefined): Re
     debug.log('ops.api', 'refused', { path: pathname, source: signal.operatorSource });
     // RES-FLOOR-API: no credential was offered at all — this endpoint names it 401; every other path keeps 403.
     if (pathname === '/v1/ops/resources') return jsonResponse({ error: 'unauthorized' }, 401);
+    // LOOP-MAP-API: a request that offers no credential at all is 401 in the same body shape;
+    // a credential that is not an operator stays 403, exactly like the neighbouring ops paths.
+    if (pathname === '/v1/ops/loops-map' && !offeredCredential(req)) return jsonResponse({ error: 'unauthorized' }, 401);
     return jsonResponse({ error: 'forbidden' }, 403);
   }
   const served = (response: Response): Response => {
@@ -226,12 +238,8 @@ export function handleOpsApi(req: Request, metaApi: MetaApiOpts | undefined): Re
     // (name·era·beat cell observedAt; null/unmeasured value and reason preserved);
     // no new remote fan-out of its own. Loop-edge joining is a later shard.
     overviewCache ??= createOverviewCache();
-    return overviewCache.get()
-      .then((overview) => served(jsonResponse({
-        generatedAt: overview.generatedAt,
-        cacheAgeMs: overview.cacheAgeMs,
-        loops: overview.loops.map((loop) => ({ name: loop.name, era: loop.era, beat: loop.beat })),
-      })), () => jsonResponse({ error: 'overview-unavailable' }, 500));
+    // peek, not get: a cold cache answers «아직 캐시 없음» instead of starting a collection.
+    return Promise.resolve(served(jsonResponse(loopsMapFromCache(overviewCache.peek()))));
   }
   if (pathname === '/v1/ops/seats') {
     const date = url.searchParams.get('date') ?? todayKst();

package/src/nexus/state/state.ts

@@ -113,7 +113,13 @@ export interface NexusEvent {
     // · tone? · glyph?). PWA's M4 `subscribeHudSegmentEvents`
     // synthesizes a FeedbackEnvelope { kind: 'hud.segment' } and routes
     // it through the M1 `applyHudSegmentEnvelope` accumulator.
-    | 'hud.segment';
+    | 'hud.segment'
+    // GRAPH-WIZARD variant 관측 (ARG-L2-DESIGNER-FU1 · 2026-10-23) — POST /v1/graphs/wizard 의
+    // variant 한 턴이 끝날 때 호출 경계(handleGraphWizardPost)가 한 건 발행한다. `detail` =
+    // { mode: 'variant', status: 'composed'|'fallback-standard', reason, goal, templateId,
+    //   growth?: { from, outcome, nodeId, returnTo? }, overlayId?, patches? }.
+    // SSE 구독자는 `?topics=graph.compose` 로 받는다.
+    | 'graph.compose';
   tabId?: string;
   detail?: Record<string, unknown>;
 }

package/src/oauth/codex-account-store.ts

@@ -32,6 +32,8 @@ import {
   decideFallback, normalizeFallbackChain, grokQuotaFromUsageSnapshot,
   type FallbackDecision, type FallbackInput, type FallbackStep, type RotationOutcome,
 } from './fallback-chain.js';
+import { collectClaudePtyMaturitySample, judgeClaudePtyMaturity, type ClaudePtyMaturity } from './claude-pty-maturity.js';
+import type { UsageOutcomesDeps } from '../budget/usage-outcomes.js';
 import { resolveGrokCredential } from '../grok/credential.js';
 import { getOpenRouterApiKey } from '../config.js';
 import { lookupOpenRouterModelSpec } from '../model-tier/llm-tier-map.js';
@@ -1087,6 +1089,29 @@ function richestCreditCandidate(candidates: readonly RotationCandidate[], reserv
   return creditCandidatesByBalance(candidates, reserve)[0];
 }
 
+/**
+ * CLAUDE-FAILOVER-FU — 체인에 `claude-pty` 칸이 «있을 때만» 런 원장의 최근 표본을 읽어 성숙도를 낸다.
+ *
+ * ⛔ 다른 체인에서는 원장을 «안 읽는다» — 비용도 0 이고, claude 를 안 쓰는 구성의 판정 입력도 안 바뀐다.
+ * ⛔ 읽기 실패·표본 결손을 «전환 가능»으로 접지 않는다 — `judgeClaudePtyMaturity(null)` 이
+ *   `sample-unreadable`(미성숙)을 내고, 판정은 `claude-pty-immature` 로 닫힌다.
+ * ⛔ 예외도 삼켜 미성숙으로 닫는다 — 원장 I/O 때문에 폴백 판정 자체가 죽으면 안 된다.
+ */
+function claudePtyMaturityForChain(
+  chain: readonly FallbackStep[],
+  ledger: UsageOutcomesDeps | undefined,
+): ClaudePtyMaturity | undefined {
+  if (!chain.includes('claude-pty')) return undefined;
+  try {
+    return judgeClaudePtyMaturity(collectClaudePtyMaturitySample(ledger ?? {}));
+  } catch (error) {
+    debug.log('oauth.claude-pty', 'maturity-read-failed', {
+      reason: error instanceof Error ? error.message.slice(0, 120) : String(error).slice(0, 120),
+    }, { level: 'warn' });
+    return judgeClaudePtyMaturity(null);
+  }
+}
+
 export function resolveRunFallback(
   env: NodeJS.ProcessEnv = process.env,
   deps: {
@@ -1098,6 +1123,8 @@ export function resolveRunFallback(
     readonly openrouterAvailable?: boolean;
     /** codex 크레딧 잔액 «확인» seam — 안 주면 회전 후보의 크레딧 신호(잔액 > 0 · 보유 ≠ false)로 잰다. */
     readonly codexCreditsAvailable?: boolean;
+    /** ⛔ 런 원장 «읽기» seam — 체인에 `claude-pty` 가 있을 때만 쓴다. 안 주면 실제 런 원장을 읽는다. */
+    readonly claudePtyLedger?: UsageOutcomesDeps;
   } & Pick<FallbackInput, 'currentStep' | 'currentCredentialRateLimited'> = {},
 ): FallbackDecision {
   try {
@@ -1160,7 +1187,13 @@ export function resolveRunFallback(
       : explicitAccount ? (explicitAccountHasCredits(snapshot, creditReserve) ? [snapshot.current.name] : [])
       : codexCreditAccountNames(snapshot.candidates, creditReserve);
     const codexCreditsAvailable = effectiveChain.includes('codex-credits') && (deps.codexCreditsAvailable ?? creditAccounts.length > 0);
-    const fallbackBase = { rotation, chain: effectiveChain, grokAvailable, grokQuota, openrouterFallbackModel, openrouterAvailable, codexCreditsAvailable };
+    // CLAUDE-FAILOVER-FU — 체인에 `claude-pty` 가 «있을 때만» 원장 성숙도를 재서 판정 입력에 싣는다.
+    //   ⛔ 없으면 `undefined` 이고 판정은 종전 그대로다(수집 0회 · 판정식 무변경).
+    const claudePtyMaturity = claudePtyMaturityForChain(effectiveChain, deps.claudePtyLedger);
+    const fallbackBase = {
+      rotation, chain: effectiveChain, grokAvailable, grokQuota, openrouterFallbackModel, openrouterAvailable, codexCreditsAvailable,
+      ...(claudePtyMaturity ? { claudePtyMaturity } : {}),
+    };
     const fallbackInput: FallbackInput = deps.currentCredentialRateLimited === true && deps.currentStep
       ? { ...fallbackBase, currentStep: deps.currentStep, currentCredentialRateLimited: true }
       : { ...fallbackBase, ...(deps.currentStep ? { currentStep: deps.currentStep } : {}) };

package/src/ops/loops-map.ts

@@ -0,0 +1,46 @@
+import type { LoopRow, OverviewSnapshot } from './overview.js';
+
+/** 루프 지도의 한 칸 — 캐시 스냅숏의 루프 행을 그대로 옮긴다(합성 없음). */
+export interface LoopsMapRow {
+  name: string;
+  era: LoopRow['era'];
+  /** 이 주기 이상 박동이 없으면 정지로 본다. null = 주기 미상(판정에서 뺀다) — 캐시 값 그대로. */
+  staleAfterSeconds: number | null;
+  /** 박동 칸: 못 잼이면 value·observedAt 이 null 이고 reason 이 남는다(캐시 그대로). */
+  beat: LoopRow['beat'];
+}
+
+/**
+ * LOOP-MAP-API 응답 — overviewCache 의 loops 스냅숏만 투영한 것.
+ * edges(loop-edges 결합)는 후속 조각이라 여기에 넣지 않는다.
+ */
+export interface LoopsMap {
+  /** 캐시 스냅숏이 만든 시각. 캐시가 비면 null. */
+  generatedAt: string | null;
+  /** 요청 시각(캐시 시계)과 generatedAt 의 차이. 캐시가 비면 null. */
+  cacheAgeMs: number | null;
+  loops: LoopsMapRow[];
+}
+
+/** 캐시 미스 응답 — 원격 조회를 유발하지 않고 «아직 캐시 없음»을 그대로 말한다. */
+const EMPTY_LOOPS_MAP: LoopsMap = { generatedAt: null, cacheAgeMs: null, loops: [] };
+
+/**
+ * overviewCache.peek() 결과 하나를 루프 지도 응답으로 투영한다.
+ * `at` 은 캐시의 시계로 잰 «읽은 시각»이라 가짜 시계를 주입하면 cacheAgeMs 가 결정적이다.
+ * 여기서 원천을 더 읽지 않는다 — 순수 투영이다.
+ */
+export function loopsMapFromCache(peeked: { snapshot: OverviewSnapshot; at: number } | null): LoopsMap {
+  if (!peeked) return EMPTY_LOOPS_MAP;
+  const generatedAtMs = Date.parse(peeked.snapshot.generatedAt);
+  return {
+    generatedAt: peeked.snapshot.generatedAt,
+    cacheAgeMs: Number.isFinite(generatedAtMs) ? Math.max(0, peeked.at - generatedAtMs) : null,
+    loops: peeked.snapshot.loops.map((loop) => ({
+      name: loop.name,
+      era: loop.era,
+      staleAfterSeconds: loop.staleAfterSeconds,
+      beat: loop.beat,
+    })),
+  };
+}

package/src/ops/overview-cache.ts

@@ -1,7 +1,7 @@
 import { debug } from '../debug/log.js';
 import { parentPort, Worker } from 'node:worker_threads';
 import { collectOverview, type CollectOptions } from './overview-collect.js';
-import { computeVerdict, unmeasured, okCell, type OverviewSnapshot, type PodMemberRow } from './overview.js';
+import { computeVerdict, unmeasured, okCell, type Cell, type GateReservation, type OverviewSnapshot, type PodMemberRow } from './overview.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getElanousConfigDirOverride, setElanousConfigDir } from '../elanous-config-dir.js';
 
@@ -12,7 +12,7 @@ const POD_STALE_MS = 2 * POD_MS;
 const MAX_MEMO = 32;
 const MAX_PENDING = 2;
 
-type PodReading = { context: string; occupied: number | null; reason: string | null; observedAt: number };
+type PodReading = { context: string; occupied: number | null; reason: string | null; observedAt: number; gate?: GateReservation };
 type OverviewData = OverviewSnapshot & ReturnType<typeof computeVerdict> & { cacheAgeMs: number; durationMs: number; sources: string[]; refreshFailed: string | null };
 type WorkerMessage = ({ kind: 'pods' } | { kind: 'snapshot'; options: CollectOptions }) & { configDir?: string };
 
@@ -25,7 +25,7 @@ if (port) {
       if (message.configDir) setElanousConfigDir(message.configDir);
       if (message.kind === 'pods') {
         const { buildGridData } = await import('../nexus/api/grid.js');
-        const rows = buildGridData().members.map((m) => ({ context: m.context, occupied: m.occupied, reason: m.reason, observedAt: Date.now() }));
+        const rows = buildGridData().members.map((m) => ({ context: m.context, occupied: m.occupied, reason: m.reason, observedAt: Date.now(), ...(m.gate ? { gate: m.gate } : {}) }));
         port.postMessage({ rows });
       } else port.postMessage({ snapshot: await collectOverview(message.options) });
     } catch (error) {
@@ -106,6 +106,24 @@ export function createOverviewCache(deps: {
     podTimer = schedule(() => { void refreshPods(); }, POD_MS);
     podTimer.unref();
   };
+  /**
+   * 게이트 예약 축(RES-FLOOR-BINDING 다섯째 축) — 「게이트 안 돎」은 측정된 값('none'), 못 잼은 사유를 남긴다.
+   * 둘 다 구속 조건 후보에서 빠지지만 뜻은 다르다: 하나는 «게이트가 안 돈다», 다른 하나는 «모른다».
+   */
+  const overlayGate = (row: PodReading | undefined, at: number): Cell<GateReservation | 'none'> => {
+    const observedAt = row ? new Date(row.observedAt).toISOString() : null;
+    const stale = row !== undefined && at - row.observedAt >= POD_STALE_MS;
+    if (podFailure || !row || stale) {
+      return unmeasured('pod pool background measure', podFailure ?? (stale ? '낡음(120초)' : '측정 대기'), observedAt);
+    }
+    if (!row.gate) return unmeasured('pod pool background measure', row.reason ?? '게이트 예약 못 잼', observedAt);
+    if (row.gate.jobs === 0) return okCell<GateReservation | 'none'>('none', 'pod pool background measure', observedAt);
+    const gate = row.gate;
+    if (!Number.isFinite(gate.unbound) || !Number.isFinite(gate.reservedMillicores) || !Number.isFinite(gate.schedulableMillicores)) {
+      return unmeasured('pod pool background measure', '게이트 CPU 못 잼', observedAt);
+    }
+    return okCell<GateReservation | 'none'>(gate, 'pod pool background measure', observedAt);
+  };
   /** Response-time Pod occupancy overlay — shared by /v1/ops/overview and /v1/ops/resources. */
   const overlayPods = (snapshot: OverviewSnapshot, at: number): PodMemberRow[] => {
     const byContext = new Map(podRows.map((row) => [row.context, row]));
@@ -115,7 +133,7 @@ export function createOverviewCache(deps: {
       const occupied = !podFailure && row && !stale && row.occupied !== null
         ? okCell(row.occupied, 'pod pool background measure', new Date(row.observedAt).toISOString())
         : unmeasured<number>('pod pool background measure', podFailure ?? (stale ? '낡음(120초)' : row?.reason ?? '측정 대기'), row ? new Date(row.observedAt).toISOString() : null);
-      return { ...pod, occupied };
+      return { ...pod, occupied, gate: overlayGate(row, at) };
     });
   };
   const present = (entry: Entry): OverviewData => {

package/src/ops/overview.ts

@@ -60,7 +60,28 @@ export interface MachineLoad {
   ioPressure?: IoPressure | null;
 }
 export interface MachineRow { name: string; load: Cell<MachineLoad> }
-export interface PodMemberRow { context: string; capacity: number; occupied: Cell<number> }
+/**
+ * GATE-RESERVE-AUTO 가 잰 «게이트 예약 몫» — 발행 게이트 샤드가 쥔 CPU. 자원 지도의 다섯째 축이다.
+ * `harnessCpuSlotsBesideGate` 와 같은 fail-closed 규칙: 샤드가 아직 노드에 안 붙었으면 하니스 Pod 는 들어가지 않는다.
+ */
+export interface GateReservation {
+  /** 종결 전 게이트 샤드 Job 수 — 0 이면 게이트가 안 돈다(축 아님). */
+  jobs: number;
+  /** 그중 아직 노드에 안 붙은 샤드. */
+  unbound: number;
+  /** 샤드가 예약한 CPU(밀리코어). */
+  reservedMillicores: number;
+  /** 스케줄 가능한 노드들의 CPU 합(밀리코어). */
+  schedulableMillicores: number;
+}
+export interface PodMemberRow {
+  context: string; capacity: number; occupied: Cell<number>;
+  /**
+   * 게이트 예약 축 — `'none'` 은 «게이트가 안 돈다»(측정됨), `unmeasured` 는 못 잼(축에서 뺀다), 항목 없음은
+   * 이 칸에 게이트 원천이 없는 스냅숏(로컬 CLI 는 호출 경로 kubectl 0 규율로 늘 여기다).
+   */
+  gate?: Cell<GateReservation | 'none'>;
+}
 export interface ParentsInfo { count: number; staleOver6h: number; oldestHours: number | null }
 export interface SchedulerMetrics {
   scheduleRuns: number | null;
@@ -110,7 +131,7 @@ export interface VerdictResult { verdict: Verdict; reasons: string[]; nextAction
 /** 부하/코어가 이 값을 넘으면 «기계 압박»(흐름 저하의 사유). */
 export const LOAD_PER_CORE_PRESSURE = 3;
 
-/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). 게이트 예약은 이 칸에 원천이 없어 늘 제외다. */
+/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). */
 export type ResourceKind = 'memory' | 'cpu' | 'io' | 'slots' | 'gate';
 
 /** 구속 조건 — 남은 비율이 최소인 축. 남은 비율 = 남은 양/전체 양(CPU 는 압박선 LOAD_PER_CORE_PRESSURE×코어를 전체로 본다). */
@@ -132,9 +153,11 @@ function remainingAmount(n: number): string {
 
 /**
  * 구속 조건 규칙(RES-FLOOR-BINDING) — 메모리·CPU·I/O·슬롯·게이트 예약 중 «남은 비율 최소»인 축이 흐름을 묶는다.
- * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 하트비트에 PSI 가 없는 I/O · 원천이 없는 게이트 예약)은 후보에서 뺀다
+ * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 하트비트에 PSI 가 없는 I/O · 게이트 CPU 못 잼)은 후보에서 뺀다
  * — «넉넉»으로도 «바닥»으로도 읽지 않는다.
- * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU→I/O, 그 다음 슬롯)의 첫 축이 이긴다.
+ * 게이트 예약의 남은 비율 = (스케줄 가능 CPU − 샤드가 쥔 CPU) / 스케줄 가능 CPU. 샤드가 아직 노드에 안 붙었으면 0
+ * (하니스 Pod 는 들어가지 않는다 · `harnessCpuSlotsBesideGate` 와 같은 규칙).
+ * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU→I/O, 그 다음 슬롯, 그 다음 게이트 예약)의 첫 축이 이긴다.
  */
 export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
   const candidates: ResourceBinding[] = [];
@@ -161,6 +184,16 @@ export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
     const total = capacity.podTarget + capacity.localMax;
     candidates.push({ kind: 'slots', label: '슬롯', remainingRatio: ratio01(capacity.free / total), remainingText: `${capacity.free}/${total}자리` });
   }
+  for (const pod of s.machines.pods) {
+    const gate = pod.gate?.value;
+    if (!gate || gate === 'none') continue;
+    const total = gate.schedulableMillicores;
+    if (!Number.isFinite(total) || total <= 0 || !Number.isFinite(gate.reservedMillicores)) continue;
+    const remaining = gate.unbound > 0 ? 0 : Math.max(0, total - gate.reservedMillicores);
+    const unbound = gate.unbound > 0 ? ` · 미배치 ${gate.unbound}` : '';
+    candidates.push({ kind: 'gate', label: `${pod.context} 게이트 예약`, remainingRatio: ratio01(remaining / total),
+      remainingText: `${remainingAmount(remaining)}/${total.toFixed(0)}밀리코어(게이트 샤드 ${gate.jobs} · 예약 ${remainingAmount(gate.reservedMillicores)}${unbound})` });
+  }
   let binding: ResourceBinding | null = null;
   for (const c of candidates) if (binding === null || c.remainingRatio < binding.remainingRatio) binding = c;
   return binding;
@@ -255,7 +288,10 @@ export function unmeasuredCells(s: OverviewSnapshot): string[] {
   visit('tasks.byOwner', s.tasks.byOwner); visit('tasks.done', s.tasks.done);
   visit('tasks.launchable', s.tasks.launchable); visit('tasks.capacity', s.tasks.capacity);
   for (const h of s.machines.hosts) visit(`machines.${h.name}`, h.load);
-  for (const p of s.machines.pods) visit(`pods.${p.context}`, p.occupied);
+  for (const p of s.machines.pods) {
+    visit(`pods.${p.context}`, p.occupied);
+    if (p.gate) visit(`pods.${p.context}.gate`, p.gate);
+  }
   visit('machines.parents', s.machines.parents); visit('landings', s.landings);
   if (s.throughput) visit('throughput', s.throughput);
   if (s.schedulerMetrics) visit('schedulerMetrics', s.schedulerMetrics);

package/src/policy/llm-policy.ts

@@ -4,7 +4,7 @@ import { isScalar, parseDocument } from 'yaml';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { DEFAULT_FALLBACK_CHAIN, isFallbackStep, type FallbackStep } from '../oauth/fallback-chain.js';
 import { isCodexQuotaPolicy } from '../oauth/codex-quota-policy.js';
-import { DEFAULT_BUDGET_GATE_MAX_USED_PERCENT, MODEL_ROLES, RUNTIME_LLM_PROVIDER_NAMES, parseRoleLlmEntry, parseSubscriptionReviewerSpec, type RoleLlmConfig, type SubscriptionReviewerSpec } from '../user-config.js';
+import { DEFAULT_BUDGET_GATE_MAX_USED_PERCENT, MODEL_ROLES, RUNTIME_LLM_PROVIDER_NAMES, parseReviewerMixSpec, parseRoleLlmEntry, parseSubscriptionReviewerSpec, type RoleLlmConfig, type SubscriptionReviewerSpec } from '../user-config.js';
 
 export interface LlmPolicy {
   version: 1;
@@ -106,6 +106,7 @@ export function validateLlmPolicy(input: unknown): LlmPolicyValidation {
     && nonempty(g.account) && positive(g.amount) && date(g.expires) && nonempty(g.source));
   const roles = (v: unknown) => object(v) && Object.entries(v).every(([role, spec]) => role === 'reviewer'
     ? !!parseSubscriptionReviewerSpec(spec)
+    : role === 'reviewerMix' ? !!parseReviewerMixSpec(spec)
     : MODEL_ROLES.some(r => r === role) && object(spec)
       && Object.keys(spec).every(k => ['provider', 'tier', 'model'].includes(k)) && parseRoleLlmEntry(spec).ok);
   check(input, 'policy', {
@@ -209,6 +210,7 @@ export function loadLlmPolicy(opts: LoadLlmPolicyOptions = {}): LoadedLlmPolicy
     if (Object.keys(base).length) overlay.default = base;
     add('roleLlm', legacy.roleLlm, overlay, 'roles', v => object(v) && Object.entries(v).every(([r, spec]) => r === 'reviewer'
       ? !!parseSubscriptionReviewerSpec(spec)
+      : r === 'reviewerMix' ? !!parseReviewerMixSpec(spec)
       : MODEL_ROLES.some(k => k === r) && parseRoleLlmEntry(spec).ok));
     add('llm.fallbackChain', llm.fallbackChain, overlay, 'fallback', v => Array.isArray(v) && v.length > 0 && v.every(isFallbackStep) && new Set(v).size === v.length);
     const codex: Obj = {};

package/src/prompt-enhance/enhance.ts

@@ -134,7 +134,7 @@ function askMarkerCount(ask: string): number {
   return (ask.match(/(?:^|\s)(?:불변식|경계|판정\s*신호|invariant|boundary|decision\s+signal)\s*:/gi) ?? []).length;
 }
 
-type EnhanceSelectionSource = 'opts' | 'env' | 'config-role' | 'fallback-child' | 'default';
+type EnhanceSelectionSource = 'opts' | 'env' | 'config-role' | 'child' | 'fallback-child' | 'default';
 const PLANNING_FALLBACK_REASONS = new Set(['quota-exhausted', 'quota-unmeasured', 'quota-unavailable', 'no-credential-source', 'expiring', 'credential-shape', 'credential-error', 'credential-unavailable', 'unavailable']);
 export function normalizePlanningFallbackReason(value: unknown): string {
   return typeof value === 'string' && PLANNING_FALLBACK_REASONS.has(value) ? value : 'unavailable';
@@ -153,7 +153,7 @@ export function selectEnhanceLlm(
   const forwardedModelSource = env.ELANOUS_PROMPT_ENHANCE_MODEL_RELAY === 'pod' ? env.ELANOUS_PROMPT_ENHANCE_MODEL_SOURCE : undefined;
   const modelSource: EnhanceSelectionSource = opts.model !== undefined ? 'opts'
     : env.ELANOUS_PROMPT_ENHANCE_MODEL
-      ? forwardedModelSource === 'config-role' || forwardedModelSource === 'fallback-child' || forwardedModelSource === 'default' ? forwardedModelSource : 'env'
+      ? forwardedModelSource === 'config-role' || forwardedModelSource === 'child' || forwardedModelSource === 'fallback-child' || forwardedModelSource === 'default' ? forwardedModelSource : 'env'
     : configuredModel !== undefined ? 'config-role' : 'default';
   const model = opts.model ?? (env.ELANOUS_PROMPT_ENHANCE_MODEL || configuredModel || env.ELANOUS_PR_REVIEW_MODEL || tierModel('better'));
   const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
@@ -176,7 +176,7 @@ export function selectEnhanceLlm(
 export function selectPlanningLlm(
   env: NodeJS.ProcessEnv = process.env,
   config: UserConfig = getUserConfig(),
-): { model: string | undefined; effort: 'low' | 'medium' | 'high'; modelSource: 'env' | 'config-role' | 'fallback-child' | 'default'; fallbackReason?: string; requestedModel?: string; requestedSource?: string } {
+): { model: string | undefined; effort: 'low' | 'medium' | 'high'; modelSource: 'env' | 'config-role' | 'child' | 'fallback-child' | 'default'; fallbackReason?: string; requestedModel?: string; requestedSource?: string } {
   const planning = config.roleLlm?.planning;
   const envModel = env.ELANOUS_PROMPT_ENHANCE_MODEL;
   const roleModel = !envModel && planning && (planning.model || planning.tier || planning.provider)
@@ -186,7 +186,7 @@ export function selectPlanningLlm(
   const relayed = env.ELANOUS_PROMPT_ENHANCE_MODEL_RELAY === 'pod';
   const forwardedSource = relayed ? env.ELANOUS_PROMPT_ENHANCE_MODEL_SOURCE : undefined;
   const modelSource = envModel
-    ? forwardedSource === 'config-role' || forwardedSource === 'fallback-child' || forwardedSource === 'default' ? forwardedSource : 'env'
+    ? forwardedSource === 'config-role' || forwardedSource === 'child' || forwardedSource === 'fallback-child' || forwardedSource === 'default' ? forwardedSource : 'env'
     : roleModel ? 'config-role' : 'default';
   const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
   const validEnvEffort = envEffort === 'low' || envEffort === 'medium' || envEffort === 'high' ? envEffort : undefined;

package/src/pty-shell/availability.ts

@@ -0,0 +1,7 @@
+import { bunNativePtyAvailable } from './bun-native-pty.js';
+
+/** Keep the capability probe independent of PTY runtime initialization. */
+export function ptyAvailable(): boolean {
+  if (bunNativePtyAvailable()) return true;
+  try { require.resolve('node-pty'); return true; } catch { return false; }
+}