elanous 0.2.36 → 0.2.38

package/src/loops/orchestrator/tick.ts

@@ -11,19 +11,21 @@ import { getUserConfig, ORCHESTRATOR_DEFAULTS, resolveConfiguredAgentRoleLlm, ty
 import { rubricPriority } from '../../release-loop/rubric.js';
 import { debug } from '../../debug/log.js';
 import { emitLoopHeartbeat } from '../neighbor-runtime.js';
+import { ConsensusEngine } from '../consensus.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../self-dev/run-store.js';
 import { planAction, runSeatLoopOnce, type SeatDeps, type SeatItem } from '../../seat-loop/seat-loop.js';
 import { addHarnessQueue, harnessQueueOutcome, setQueuedPoolHint } from '../../harness/harness-queue.js';
 import { placeOnGrid, type GridHost } from './grid-place.js';
 import { checkPodPool, parsePodPool, resolvePodPoolSpec } from '../../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl } from '../../task-orchestrator/surfaces/pod-lease.js';
+import { defaultAnomalyCluster, extractContainerExit, type AnomalyCluster } from './anomaly-cluster.js';
 import { isLaunchEligible, isTrafficLaunch, recordDispatchCycle, seatOfTree, type TrafficProcess } from './traffic.js';
 import { defaultListHarnessProcesses } from '../../harness/harness-cli-command.js';
 import * as testGuard from '../../instance/test-write-guard.js';
 import { seatCapDetails } from '../budget.js';
 export { isLaunchEligible } from './traffic.js';
 import { readTaskAgentState, TASK_SEATS, type HandTaskOptions, type TaskCard as TaskAgentCard, type HandTaskResult, type TaskLauncher, type TaskSeat } from '../../task-agent/task-hand.js';
-import { runCoordinatorAgentInbox, runCoordinatorInbox, type CoordinatorInboxResult } from './inbox.js';
+import { runAskOpContextInbox, runCoordinatorAgentInbox, type CoordinatorInboxResult } from './inbox.js';
 import type { KnowhowOptions } from './knowhow-pack.js';
 import { loadAgentRolePack, type AgentReplyInput } from '../agent-reply.js';
 import type { LLMProvider } from '../../llm.js';
@@ -32,7 +34,7 @@ export type Window = '08' | '12' | '18';
 export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'reconcile' | 'report';
 export type Mode = 'off' | 'shadow' | 'live';
 const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cmo-seat', TC: 'tc-seat', UX: 'ux-seat' };
-export interface Cell { id: string; title: string; kind?: string; seat?: string; host?: string; gridHost?: boolean; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2' | 'P3' | 'P4'; predecessors?: string[] }
+export interface Cell { id: string; title: string; kind?: string; seat?: string; host?: string; gridHost?: boolean; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2' | 'P3' | 'P4'; predecessors?: string[]; consensusProposalId?: string }
 export interface TickState {
   runId: string; window: Window; mode: Mode; day: string;
   cards: TaskCard[]; skippedCards: Array<{ id: string; reason: string }>; cells: Cell[]; placed: number; unplaced?: number; delegated: number; wouldDelegate: number; rebalanced?: number; rebalanceBlocked?: Array<{ id: string; reason: string }>;
@@ -58,7 +60,7 @@ export interface TickState {
   missing: string[];
 }
 /** FLOW1a contract: with `{ shadow: true }` the splitter only proposes cells and writes nothing (cards, ledgers, LLM side effects excepted). */
-export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Promise<Array<{ id: string; title: string; kind?: string; seat?: string; host?: string }>> | Array<{ id: string; title: string; kind?: string; seat?: string; host?: string }>;
+export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Promise<Array<{ id: string; title: string; kind?: string; seat?: string; host?: string; consensusProposalId?: string }>> | Array<{ id: string; title: string; kind?: string; seat?: string; host?: string; consensusProposalId?: string }>;
 /** RELPLAN1 `placeCell(input: PlacementCell)` — owner·priority·predecessors are required; the result carries no seat. */
 export type PlacementInput = { id: string; title: string; owner: string; priority: 'P0' | 'P1' | 'P2'; predecessors: string[] };
 export type PlaceAdapter = (cell: PlacementInput, deps?: { dryRun?: boolean; now?: Date }) => Promise<{ version?: string } | null> | { version?: string } | null;
@@ -73,6 +75,8 @@ export interface TickDeps {
   gridHosts?: readonly GridHost[];
   seatTurn?: (seat: string, root: string, host?: string, options?: Pick<SeatDeps, 'enqueue'>) => Promise<{ status: string; queueId?: string; runId?: string; item?: { source: string; id: string } }>;
   queueOutcome?: (queueId: string, root: string) => 'pending' | 'unknown' | 'retryable' | 'succeeded';
+  /** ANOMALY-CLUSTER — grouping state shared with the dispatcher relaunch gate; defaults to the process-wide instance. */
+  anomalyCluster?: AnomalyCluster;
   /** Snapshot of running harness processes for launch-cap decisions; an unreadable snapshot blocks launches. */
   launchProcesses?: () => { status: 'ok'; records: readonly TrafficProcess[] } | { status: 'incomplete' };
   /** 발사 전 대기열 항목의 풀 힌트 갱신(주입 안 하면 harness-queue `setQueuedPoolHint`). */
@@ -93,6 +97,8 @@ export interface TickDeps {
   coordinatorAgentProvider?: LLMProvider;
   /** Resident knowhow pack seam; the real intake reads 내부 문서 `KNOWHOW` every tick. */
   coordinatorKnowhow?: KnowhowOptions | false;
+  /** Deterministic read-only ask-op context seam for isolated tick tests. */
+  coordinatorContext?: typeof import('../../context-bus/context-now.js').askOpContextBundle;
 }
 
 /** ORCH-TA-HAND ledger — one row per handed `orch:<card>:<cell>` key so a cell is handed once across ticks and processes. */
@@ -453,6 +459,22 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   const root = deps.root ?? effectiveInstanceRoot();
   const runId = deps.runId ?? graphRunId() ?? `${kstDay(now)}-${window}`;
   const path = stateFile(root, runId);
+  const consensus = new ConsensusEngine({ stateDir: root });
+  const consensusAllows = (cell: Cell): boolean => {
+    if (cell.kind !== 'cross-branch-change' && !cell.consensusProposalId) return true;
+    const workKey = `orch:${cell.cardId}:${cell.id}`;
+    try {
+      if (cell.kind === 'cross-branch-change') {
+        const proposal = consensus.proposalForWork(workKey);
+        if (!proposal || (cell.consensusProposalId && cell.consensusProposalId !== proposal.id)) return false;
+        cell.consensusProposalId = proposal.id;
+      }
+      return !!cell.consensusProposalId && consensus.canExecute(cell.consensusProposalId);
+    } catch (error) {
+      debug.log('loop.orchestrator', 'consensus-gate-failed', { id: cell.consensusProposalId, workKey, error: String(error) }, { level: 'warn' });
+      return false;
+    }
+  };
   const orchestratorConfig = getUserConfig().loops?.orchestrator;
   const configured = deps.mode ?? orchestratorConfig?.mode;
   const mode: Mode = configured === 'off' || configured === 'live' ? configured : 'shadow';
@@ -501,8 +523,9 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         ? runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), path: inboxPath, root,
             ...(deps.coordinatorAgentRun ? { runAgent: deps.coordinatorAgentRun } : {}),
             ...(deps.coordinatorAgentProvider ? { provider: deps.coordinatorAgentProvider } : {}) })
-        : runCoordinatorInbox(undefined, 100, inboxPath,
-          deps.coordinatorKnowhow === undefined ? {} : { knowhow: deps.coordinatorKnowhow });
+        : runAskOpContextInbox({ path: inboxPath, limit: 100,
+            ...(deps.coordinatorKnowhow === undefined ? {} : { knowhow: deps.coordinatorKnowhow }),
+            ...(deps.coordinatorContext ? { context: deps.coordinatorContext } : {}) });
     }))();
     if (inbox.replied || inbox.acknowledged) {
       observe('exchange', 'coordinator-inbox-replied', inbox.replied);
@@ -529,9 +552,12 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         const cells = ruleOnly ? [{ id: card.id, title: card.title }] : split ? await split(card, { shadow: mode === 'shadow' }) : [{ id: card.id, title: card.title }];
         for (const cell of cells) {
           if (!cell.id?.trim() || !cell.title?.trim()) throw new Error('invalid split cell');
+          const workKey = `orch:${card.id}:${cell.id}`;
+          const proposalId = cell.consensusProposalId ?? (cell.kind === 'cross-branch-change' ? consensus.proposalForWork(workKey)?.id : undefined);
           state.cells.push({ cardId: card.id, id: cell.id, title: cell.title, origin: split ? 'flow1a' : 'candidate',
             ...(ruleOnly ? { priority: rubricPriority(card.sections.map(section => section.content).join('\n')) } : {}),
-            ...(cell.kind !== undefined ? { kind: cell.kind } : {}), ...(cell.seat ? { seat: cell.seat } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}) });
+            ...(cell.kind !== undefined ? { kind: cell.kind } : {}), ...(cell.seat ? { seat: cell.seat } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}),
+            ...(proposalId ? { consensusProposalId: proposalId } : {}) });
         }
         observe('exchange', `split:${card.id}`, cells.length);
         if (split && cells.length && mode === 'live') {
@@ -567,6 +593,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         }
         if (available && (mode === 'live' || !deps.placeCell)) for (const cell of state.cells) {
           if (cell.origin !== 'flow1a' || !cell.seat || !SEAT_LOOP_IDS[cell.seat]) continue;
+          if (!consensusAllows(cell)) { observe('consensus-blocked', cell.consensusProposalId, 1); continue; }
           // RELPLAN's dryRun calculates the same release without writing a checklist in shadow.
           try {
             const priority = cell.priority === 'P3' || cell.priority === 'P4' ? 'P2' : cell.priority ?? 'P2';
@@ -645,6 +672,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       };
       for (const cell of state.cells) {
         if (cell.origin !== 'flow1a' || !cell.seat) continue;
+        if (!consensusAllows(cell)) { observe('consensus-blocked', cell.consensusProposalId, 1); continue; }
         const targetLoopId = SEAT_LOOP_IDS[cell.seat];
         if (!targetLoopId) continue;
         const key = `orch:${cell.cardId}:${cell.id}`;
@@ -674,6 +702,17 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           // shadow 표본은 따로 센다 — 자리 경로로 아직 안 간 칸(shadow 틱·배치 전)이 나중에 live 로 바뀌면 그때 뜬다.
           // ⚠️ 이미 자리 저널에 들어간 칸은 live 로 바꿔도 다시 안 넘긴다(keys.has 에서 끝) — 한 칸의 발사 주체는 하나다(의도).
           const handKey = handLive ? key : `shadow:${key}`;
+          // ANOMALY-CLUSTER: the goal·host pair is the hold key (never part of the failure signature). While a
+          // signature with 3+ runs is un-judged, its relaunch is held and the cell is carried to the next tick.
+          const anomalyGoal = cell.cardId;
+          const anomalyHost = cell.seat;
+          const anomaly = deps.anomalyCluster ?? defaultAnomalyCluster();
+          const hold = anomaly.hold(anomalyGoal, anomalyHost);
+          if (hold.hold) {
+            (state.deferredCells ??= []).push(cell);
+            observe('anomaly-cluster-hold', `${key}:${hold.reason}`, 1, 'task-agent');
+            continue;
+          }
           mkdirSync(dirname(ledger), { recursive: true });
           mkdirSync(dirname(path), { recursive: true });
           // Claim under the seat-journal lock — the same lock the seat append takes, so a live claim and a seat row never both land.
@@ -693,9 +732,18 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
               withFileLockSync(`${path}.lock`, () => appendFileSync(ledger, `${JSON.stringify({ key: handKey, cell: cell.id, cardId: result.card.id, mode: result.mode, launched: result.launched, status: 'handed', runId, at: now.toISOString() })}\n`));
               (state.handed ??= []).push({ key, cell: cell.id, cardId: result.card.id, mode: result.mode, launched: result.launched });
               observe('hand-to-task-agent', `${key}:${result.card.id}:${result.mode}${result.launched ? ':launched' : ''}`, 1, 'task-agent');
+              // A hand that went through is the cause verdict for this goal·host — clear a pending hold.
+              if (anomaly.isHeld(anomalyGoal, anomalyHost)) anomaly.release(anomalyGoal, anomalyHost, '원인 판정: hand-to-task-agent 성공');
               // A live hand is an assignment: it counts toward maxDelegatePerTick like a seat row (COORD-HA ②).
               if (handLive) { keys.add(key); state.delegatedKeys?.push(key); continue; }
             } catch (error) {
+              // ANOMALY-CLUSTER record point: signature from kind·container exit·stage·reason tail of lastLines.
+              const failureLines = [String(error)];
+              anomaly.record({
+                goal: anomalyGoal, host: anomalyHost, runId,
+                kind: 'hand-to-task-agent-failed', containerExit: extractContainerExit(failureLines[0]!),
+                stage: 'delegate', lastLines: failureLines, at: now.toISOString(),
+              });
               observe('hand-to-task-agent-failed', `${key}:${String(error).slice(0, 160)}`, 1, 'task-agent');
               // A failed live hand stays claimed (no relaunch loop) and does not fall back to the seat path — one launcher per cell.
               if (handLive) { keys.add(key); continue; }
@@ -754,7 +802,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       // shadow 는 저널을 읽지 않는다 — 깨진 live 저널이 관측 전용 틱을 넘어뜨리지 않게.
       const latestRequests = new Map(mode === 'live' && state.degradation?.level !== 2 ? readRequests(root).map(row => [row.key, row]) : []);
       const eligible = state.cells.filter(cell => state.degradation?.level !== 2 && cell.origin === 'flow1a' && cell.seat && SEAT_LOOP_IDS[cell.seat]
-        && validVersion(cell.version) && (mode === 'shadow' || latestRequests.get(`orch:${cell.cardId}:${cell.id}`)?.status === 'queued')
+        && consensusAllows(cell) && validVersion(cell.version) && (mode === 'shadow' || latestRequests.get(`orch:${cell.cardId}:${cell.id}`)?.status === 'queued')
         && (orchestratorConfig?.maxDelegatePerTick === undefined || state.delegatedKeys?.includes(`orch:${cell.cardId}:${cell.id}`)
           || (mode === 'live' && latestRequests.has(`orch:${cell.cardId}:${cell.id}`))));
       const seats = [...new Set(eligible.map(cell => cell.seat!))];

package/src/maturity/feature-maturity.ts

@@ -137,6 +137,7 @@ export const FEATURE_MATURITY = {
     tablet: 'ops',
     surface: 'ops',
     term: 'tool',
+    side: 'tool',
     claude: 'tool',
     codex: 'tool',
     gemini: 'tool',

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/channel-ask-op.ts

@@ -0,0 +1,96 @@
+import type { Message, MessageEnvelope } from '../../msg/msg-store.js';
+import type { TgSlashCommand } from '../../telegram-commands.js';
+import { ASK_OP_COMMAND, formatAskOpQuestionEnvelope } from '../../session/channel-ask-op-envelope.js';
+
+export interface AskOpTelegramOptions {
+  allowedUserIds: readonly number[];
+  append: (message: MessageEnvelope, provenanceKey: string) => Message;
+}
+
+export interface AskOpDiscordOptions {
+  allowedUserIds: readonly string[];
+  allowedChannelIds: readonly string[];
+  resolveBotId: () => Promise<string>;
+  append: (message: MessageEnvelope, provenanceKey: string) => Message;
+}
+
+export interface AskOpDiscordContext {
+  userId: string;
+  channelId: string;
+  messageId: string;
+  text: string;
+}
+
+function appendAskOpQuestion(
+  options: { append: AskOpTelegramOptions['append'] },
+  input: { from: 'TELEGRAM' | 'DISCORD'; surface: string; correlation: string[]; question: string; provenanceKey: string },
+): Message {
+  return options.append({
+    from: input.from,
+    to: 'COORDINATOR',
+    kind: 'question',
+    body: [`${input.surface} /${ASK_OP_COMMAND}`, ...input.correlation, `question: ${input.question}`].join('\n'),
+  }, input.provenanceKey);
+}
+
+function extractQuestion(text: string): string | null {
+  const match = new RegExp(`^/(?:${ASK_OP_COMMAND}|ask-op)(?:@[-_a-z0-9]+)?(?:\\s+([\\s\\S]*))?$`, 'i').exec(text.trim());
+  const question = match?.[1]?.trim();
+  return question || null;
+}
+
+export function createAskOpTelegramSlashCommand(options: AskOpTelegramOptions): TgSlashCommand {
+  return {
+    name: ASK_OP_COMMAND,
+    description: '운영 책임자에게 질문을 보냅니다',
+    handler: async (_args, ctx) => {
+      if (!options.allowedUserIds.includes(ctx.userId)) return '허용된 사용자만 OP에게 질문할 수 있습니다.';
+      const question = extractQuestion(ctx.text);
+      if (!question) return `사용법: /${ASK_OP_COMMAND} <질문>`;
+      if (!Number.isSafeInteger(ctx.updateId) || ctx.updateId < 0) return 'Telegram update 식별값을 확인할 수 없어 질문을 저장하지 못했습니다.';
+
+      const botId = (ctx.botId ?? 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+      const message = options.append({
+        from: 'TELEGRAM',
+        to: 'COORDINATOR',
+        kind: 'question',
+        body: formatAskOpQuestionEnvelope({
+          surface: 'telegram', botId, chatId: ctx.chatId, threadId: ctx.threadId,
+          messageId: ctx.messageId, updateId: ctx.updateId, question,
+        }),
+      }, `coord:tg-${botId}-${ctx.updateId}:COORDINATOR`);
+
+      return `OP에게 질문 #${message.id}로 접수했습니다.`;
+    },
+  };
+}
+
+/** Handle a Discord text command from an already-routed message. Returning
+ * undefined leaves every non-/askop message on its existing chat path. */
+export function createAskOpDiscordIngress(options: AskOpDiscordOptions) {
+  return async (ctx: AskOpDiscordContext): Promise<string | undefined> => {
+    const match = new RegExp(`^/${ASK_OP_COMMAND}(?:\\s+([\\s\\S]*))?$`, 'i').exec(ctx.text.trim());
+    if (!match) return undefined;
+    if (!options.allowedUserIds.includes(ctx.userId)) return '허용된 사용자만 OP에게 질문할 수 있습니다.';
+    if (!options.allowedChannelIds.includes(ctx.channelId)) return '허용된 Discord 채널에서만 OP에게 질문할 수 있습니다.';
+    const question = match[1]?.trim();
+    if (!question) return `사용법: /${ASK_OP_COMMAND} <질문>`;
+    if (!/^\d+$/.test(ctx.messageId)) return 'Discord 메시지 식별값을 확인할 수 없어 질문을 저장하지 못했습니다.';
+
+    let botId: string;
+    try { botId = await options.resolveBotId(); }
+    catch { return 'Discord 봇 식별값을 확인할 수 없어 질문을 저장하지 못했습니다.'; }
+    if (!/^[A-Za-z0-9_-]+$/.test(botId)) return 'Discord 봇 식별값이 올바르지 않아 질문을 저장하지 못했습니다.';
+
+    const message = appendAskOpQuestion(options, {
+      from: 'DISCORD', surface: 'Discord',
+      correlation: [
+        `botId=${botId}`, `channelId=${ctx.channelId}`,
+        `messageId=${ctx.messageId}`, `updateId=${ctx.messageId}`,
+      ],
+      question,
+      provenanceKey: `coord:dc-${botId}-${ctx.messageId}:COORDINATOR`,
+    });
+    return `OP에게 질문 #${message.id}로 접수했습니다.`;
+  };
+}

package/src/nexus/api/discord-trigger-bot.ts

@@ -37,6 +37,8 @@ import { createDiscordStreamSink } from '../../session/streaming/discord-stream-
 import { splitForDiscord } from '../../discord.js';
 import { formatForDiscord } from '../../discord-markdown.js';
 import { receiveChannelEvent } from '../outbound/router.js';
+import { openMsgStore } from '../../msg/msg-store.js';
+import { createAskOpDiscordIngress } from './channel-ask-op.js';
 
 export interface NexusDiscordTriggerBotOpts {
   /** Bot token (without `Bot ` prefix). Production reads
@@ -156,6 +158,30 @@ export function createNexusDiscordTriggerBot(
   // LF2 — 콘솔 하트비트 유지 + debug.log 병행(telegram-trigger 동형).
   const log = opts.log ?? createDiscordTriggerLogger();
   const onTriggerTap = buildDiscordTriggerTap(opts.dispatch, log);
+  let botRef: DiscordBot | undefined;
+  let botIdPromise: Promise<string> | undefined;
+  const askOpIngress = createAskOpDiscordIngress({
+    allowedUserIds: opts.allowedUsers,
+    allowedChannelIds: opts.guildTextChannels ?? [],
+    resolveBotId: () => {
+      if (!botRef) return Promise.reject(new Error('Discord bot is not ready'));
+      botIdPromise ??= botRef.getMe().then(({ id }) => id).catch((error: unknown) => {
+        botIdPromise = undefined;
+        throw error;
+      });
+      return botIdPromise;
+    },
+    append: (message, provenanceKey) => {
+      const store = openMsgStore();
+      try { return store.appendWithProvenance(message, provenanceKey); }
+      finally { store.close(); }
+    },
+  });
+  const onMessage: DcMessageHandler = async (ctx, streamer) => {
+    const askReply = await askOpIngress(ctx);
+    if (askReply !== undefined) return askReply;
+    return opts.onMessage?.(ctx, streamer);
+  };
 
   const botWasInjected = opts.bot !== undefined;
   const bot = opts.bot ?? new DiscordBot({
@@ -165,7 +191,7 @@ export function createNexusDiscordTriggerBot(
     // Chat path: the injected self-turn handler (M4b nexus wire) or the
     // legacy trigger-only no-op. Workflows wanting a chat reply can
     // still declare a `chatTrigger` (routes via `/v1/workflows/chat/*`).
-    onMessage: opts.onMessage ?? (async () => undefined),
+    onMessage,
     log,
     onTriggerTap,
     ...(opts.voiceTap ? { voiceTap: opts.voiceTap } : {}),
@@ -173,6 +199,7 @@ export function createNexusDiscordTriggerBot(
     ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
     ...(opts.wsImpl ? { wsImpl: opts.wsImpl } : {}),
   });
+  botRef = bot;
 
   // §C3 — discord 서피스 sink(config gate·telegram-trigger 동형). shadowFanout OR
   // primary.discord 시 등록. endpoint 완전스코프면 parse→인스턴스 가드 후 channelId 배달,

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();