elanous 0.2.37 → 0.2.38

package/src/llm.ts

@@ -62,7 +62,7 @@ import { BUILTIN_CATALOG, reasoningEffortCeiling as reasoningEffortCeilingOf } f
 import { inferProviderFromModel as registryInferProviderFromModel } from './registry/normalize.js';
 import { closestMatches } from './tool-name-suggest.js';
 import { createProviderToolNameMap } from './llm-tool-name.js';
-import { isOpenRouterGrokModel, sanitizeToolSchemaForGrok } from './llm-tool-schema.js';
+import { assertNoTopLevelToolSchemaCombinators, isOpenRouterGrokModel, sanitizeToolSchemaForGrok } from './llm-tool-schema.js';
 import { undoTurnRuntime } from './tool-runtime/undo-turn-runtime.js';
 import { listSnapshots } from './undo-turn/index.js';
 // Zero-dep spec module (no tool-runtime registry) — safe for this hot path.
@@ -403,6 +403,9 @@ export type ToolChoice = 'auto' | 'required' | 'none' | { name: string };
 
 export interface LLMOpts {
   model?: string;
+  /** Explicit research surface verdict from the turn router. Relaxes early
+   *  exploration guards while retaining a finite tool-loop hard stop. */
+  researchTurn?: boolean;
   /** Reports the provider and model actually attempted, including fallbacks. */
   onResolvedProvider?(provider: string, model: string): void;
   temperature?: number;
@@ -4471,6 +4474,7 @@ function explainAndLogFallbackCandidates(
 
 /** 스트림 중 끊김 재시도 상한 — codex `DEFAULT_STREAM_MAX_RETRIES`(5) 와 같은 값. */
 const STREAM_DISCONNECT_MAX_RETRIES = 5;
+const STREAM_IDLE_TIMEOUT_MAX_RETRIES = 1;
 let streamDisconnectRetryDelayMs: (attempt: number) => number = backoffMs;
 
 /** @internal 시험 seam — 재시도 대기(기본 `backoffMs`)를 바꾼다. `undefined` 면 원복. */
@@ -4904,6 +4908,7 @@ export async function streamLLM(
     );
     activeProvider = finalized.provider;
     const activeModel = finalized.model;
+    if (getModelFamily(activeModel) === 'claude') assertNoTopLevelToolSchemaCombinators(opts.tools);
     opts.onResolvedProvider?.(activeProvider.name, activeModel);
     debug.log('llm.router', 'streamLLM', {
       provider: activeProvider.name,
@@ -5118,6 +5123,8 @@ export function resolveDefaultProvider(model?: string): LLMProvider {
 export interface StreamWithToolsHandlers {
   /** Streaming text delta — invoked for every text chunk across all turns. */
   onText(delta: string, fullAcrossTurns: string): void;
+  /** Optional status line for hosts that surface transient stream recovery. */
+  onStatus?(line: string): void;
   /** Dispatch a tool call. Returning undefined/null throws in the loop so
    *  callers should always return a JSON-serializable value (can be an
    *  error object — the model will see it as a tool_result either way).
@@ -7382,6 +7389,16 @@ function resultText(result: unknown): string {
   return '';
 }
 
+/** skill_exec returns structured host metadata, but its model-facing tool result is the answer body. */
+function toolResultContentForCall(toolName: string, result: unknown): string {
+  if (toolName === 'skill_exec' && result && typeof result === 'object'
+    && typeof (result as { output?: unknown }).output === 'string') {
+    if ((result as { ok?: unknown }).ok === false) return JSON.stringify(result);
+    return (result as { output: string }).output;
+  }
+  return typeof result === 'string' ? result : JSON.stringify(result);
+}
+
 function detectExecutionFailure(result: unknown): boolean {
   if (!result || typeof result !== 'object') return false;
   const typed = result as Record<string, unknown>;
@@ -8409,7 +8426,9 @@ export async function streamLLMWithTools(
   const familyDefaultMaxTurns = resolved === 0 ? Number.POSITIVE_INFINITY : (resolved || baselineForFamily);
   // `let` (not const) — the conditional budget-grant hook (opts.budgetGrant)
   // may extend this mid-loop when a designated multi-round tool is called.
-  let maxTurns = opts.maxTurns ?? familyDefaultMaxTurns;
+  let maxTurns = opts.maxTurns ?? (opts.researchTurn
+    ? Math.min(32, Math.max(16, familyDefaultMaxTurns))
+    : familyDefaultMaxTurns);
   const budgetGrant = opts.budgetGrant;
   // ⭐ Hydration-capable tool list (F2 gap④ · 2026-07-26). The provider tool
   // array used to be `opts.tools`, FIXED for the whole loop. That made
@@ -8428,7 +8447,9 @@ export async function streamLLMWithTools(
   } catch { /* config unreadable — default 비-면제·hot-path 는 config 손상에 안 막힌다 */ }
   const inspectBudgetThreshold = getInspectBudgetThreshold(history, modelFamily, codexInspectExemptFlag);
   const inspectFollowupMode = getInspectFollowupMode(history);
-  const explorationThresholdForTurn = getExplorationThreshold(history, maxTurns, modelFamily);
+  const explorationThresholdForTurn = opts.researchTurn
+    ? Number.POSITIVE_INFINITY
+    : getExplorationThreshold(history, maxTurns, modelFamily);
   const maxTurnsUnbounded = maxTurns === Infinity;
   const familyDefaultMaxTurnsUnbounded = familyDefaultMaxTurns === Infinity;
   const explorationUnbounded = !Number.isFinite(explorationThresholdForTurn);
@@ -8443,6 +8464,7 @@ export async function streamLLMWithTools(
       inspectBudgetThreshold,
       inspectFollowupMode,
       explorationThresholdForTurn,
+      researchTurn: opts.researchTurn === true,
       // ★ Infinity 는 JSON 직렬화 시 null 이 되므로 boolean 으로도 남긴다(관측·제1원칙).
       //   true = 프론티어 면제로 read/search 스트릭 컷 없음(대표 방침 2026-07-17).
       explorationUnbounded,
@@ -8831,7 +8853,7 @@ export async function streamLLMWithTools(
     let turnOpts = buildTurnOpts();
     // reasoning-heavy family(codex/claude/gemini/grok/local)는 침묵 추론 구간이 길어 idle watchdog 를
     // family-aware 로 상향(2026-07-19 goal-exec → 아크4 전-family). fast/mini(gpt·other)만 45s 유지.
-    const streamIdleTimeoutMs = usesLongReasoningIdle(modelFamily, activeProvider.name) ? STREAM_IDLE_TIMEOUT_MS_REASONING : STREAM_IDLE_TIMEOUT_MS;
+    const streamIdleTimeoutMs = opts.streamIdleTimeoutMs ?? (usesLongReasoningIdle(modelFamily, activeProvider.name) ? STREAM_IDLE_TIMEOUT_MS_REASONING : STREAM_IDLE_TIMEOUT_MS);
     // ⚠️ hang 진단(2026-07-17) — codex SSE 스트림이 완료 신호 없이 안 끝나는 케이스 확정용.
     // consume-start 후 consume-end 가 없으면 = for-await(streamChat SSE) hang. lastEvType 로 어느
     // 이벤트 뒤에서 멈추는지(usage/text/tool_call) 특정. 무장할 상한도 남겨 실험 런을 구별한다.
@@ -8847,6 +8869,7 @@ export async function streamLLMWithTools(
     // ⭐ TUI-STREAM-RETRY(2026-10-14 실측) — 200 OK 로 흐르던 스트림이 소켓 끊김으로 죽으면 같은 공급자로
     //   다시 건다(codex `stream_max_retries` 동형). 이 턴에서 받은 tool_call·image 가 있으면 재시도하지 않는다.
     let streamDisconnectRetries = 0;
+    let streamIdleTimeoutRetries = 0;
     let streamEmittedImage = false;
     // 끊긴 조각을 이력(turnText·fullText)에서 «조용히» 되감는다 — 화면엔 지우라고 알리지 않는다
     //   (TUI 의 빈 델타는 «커밋»이다). 이미 보인 글과 겹치는 재시도 본문은 `retryDisplay` 가 막는다.
@@ -8878,6 +8901,9 @@ export async function streamLLMWithTools(
     while (true) {
       let idleTimer: ReturnType<typeof setTimeout> | undefined;
       let step: { idle: true } | { idle: false; r: IteratorResult<LLMStreamEvent, void> };
+      // Validate before entering the provider stream's catch/fallback boundary.
+      // An incompatible request is deterministic and must not be retried elsewhere.
+      if (getModelFamily(activeModel) === 'claude') assertNoTopLevelToolSchemaCombinators(turnOpts.tools);
       try {
         if (!streamIter) {
           const finalized = finalizeStreamingProviderModel(activeProvider, activeModel);
@@ -8918,8 +8944,46 @@ export async function streamLLMWithTools(
           streamIter.next().then((r) => ({ idle: false as const, r })),
           new Promise<{ idle: true }>((res) => { idleTimer = setTimeout(() => res({ idle: true }), streamIdleTimeoutMs); }),
         ]);
+        if (step.idle) {
+          const error = new Error(`stream idle timeout after ${streamIdleTimeoutMs}ms`);
+          error.name = 'StreamIdleTimeoutError';
+          Object.assign(error, { code: 'ETIMEDOUT' });
+          throw error;
+        }
       } catch (err) {
         if (idleTimer) clearTimeout(idleTimer);
+        if (err instanceof Error && err.name === 'StreamIdleTimeoutError') {
+          debug.log('llm.stream', 'idle-timeout', {
+            turn, evCount, lastEvType, idleMs: streamIdleTimeoutMs,
+            textChars: turnText.length, pendingCalls: pendingCalls.length,
+          }, { level: 'warn' });
+          // A provider async iterator can queue return() behind the pending next().
+          // Detach cleanup so it cannot keep the user turn busy forever.
+          const timedOutIterator = streamIter;
+          if (timedOutIterator?.return) {
+            try { void Promise.resolve(timedOutIterator.return(undefined)).catch(() => {}); } catch { /* fail-soft cleanup */ }
+          }
+          if (streamIdleTimeoutRetries < STREAM_IDLE_TIMEOUT_MAX_RETRIES
+            && pendingCalls.length === 0 && !streamEmittedImage && !opts.signal?.aborted) {
+            streamIdleTimeoutRetries++;
+            debug.log('llm.retry', 'idle-timeout-retry', {
+              provider: activeProvider.name, model: activeModel, turn,
+              attempt: streamIdleTimeoutRetries, maxRetries: STREAM_IDLE_TIMEOUT_MAX_RETRIES,
+              delayMs: 0, statusLine: '스트림 무응답 · 재시도',
+            }, { level: 'warn' });
+            handlers.onStatus?.(`스트림 무응답 · 재시도 ${streamIdleTimeoutRetries}/${STREAM_IDLE_TIMEOUT_MAX_RETRIES}`);
+            rewindDisconnectedStream();
+            streamIter = undefined;
+            continue;
+          }
+          // Once a tool call/image escaped, keep the old behavior: finish this
+          // provider turn and never replay or switch providers around side effects.
+          if (pendingCalls.length > 0 || streamEmittedImage || opts.signal?.aborted) break;
+          if (opts.provider) break; // pinned route preserves the prior partial-text result
+          // The retry's text was already sent to the view; drop it from the
+          // logical result before allowing the normal provider fallback path.
+          if (pendingCalls.length === 0 && !streamEmittedImage) rewindDisconnectedStream();
+        }
         if (err instanceof OverloadFailoverError && !opts.provider) {
           const switched = activeProvider.name === 'openai-codex'
             ? firstAvailableFallbackProvider(attemptedProviders, opts)
@@ -8934,6 +8998,7 @@ export async function streamLLMWithTools(
               status: err.status,
               kind: err.kind,
             }, { level: 'warn' });
+            handlers.onStatus?.(`⚠ 공급자 전환: ${activeProvider.name} → ${switched.name} (${err.kind ?? err.name ?? 'unknown'})`);
             const finalized = finalizeStreamingProviderModel(switched, switched.defaultModel);
             activeProvider = finalized.provider;
             activeModel = finalized.model;
@@ -8944,7 +9009,8 @@ export async function streamLLMWithTools(
             continue;
           }
         }
-        if (evCount > 0 && isStreamDisconnectRetryable(err, pendingCalls.length, streamEmittedImage) && !opts.signal?.aborted) {
+        if (!(err instanceof Error && err.name === 'StreamIdleTimeoutError')
+          && evCount > 0 && isStreamDisconnectRetryable(err, pendingCalls.length, streamEmittedImage) && !opts.signal?.aborted) {
           const retryData = {
             provider: activeProvider.name,
             model: activeModel,
@@ -9013,6 +9079,7 @@ export async function streamLLMWithTools(
           tools: activeTools.map((tool) => tool.name),
           ...(opts.model ? { modelOverrideDropped: opts.model } : {}),
         }, { level: 'warn' });
+        handlers.onStatus?.(`⚠ 공급자 전환: ${activeProvider.name} → ${fallback.name} (${verdict.category})`);
         const finalized = finalizeStreamingProviderModel(fallback, fallback.defaultModel);
         activeProvider = finalized.provider;
         activeModel = finalized.model;
@@ -9025,9 +9092,9 @@ export async function streamLLMWithTools(
       }
       if (idleTimer) clearTimeout(idleTimer);
       if (step.idle) {
-        debug.log('llm.stream', 'idle-timeout', { turn, evCount, lastEvType, idleMs: streamIdleTimeoutMs, textChars: turnText.length, pendingCalls: pendingCalls.length }, { level: 'warn' });
-        try { await streamIter.return?.(undefined); } catch { /* fail-soft — 스트림 정리 실패 무시 */ }
-        break;
+        // The race's idle branch is converted to StreamIdleTimeoutError above.
+        // Keep a fail-closed guard for future changes to this loop.
+        throw new Error('stream idle timeout branch escaped recovery');
       }
       if (step.r.done) break;
       const ev = step.r.value;
@@ -10289,7 +10356,8 @@ export async function streamLLMWithTools(
           //    rejection without colliding with the auto-narrow path)
           //  - call is in SEARCH_ONLY_TOOLS
           if (
-            dispatchedReadCount === 0
+            !opts.researchTurn
+            && dispatchedReadCount === 0
             && autoNarrowedReadCount === 0
             && searchOnlyTurnStreak >= 3
             && SEARCH_ONLY_TOOLS.has(call.name)
@@ -11066,7 +11134,7 @@ export async function streamLLMWithTools(
           resultBlocks.push({
             type: 'tool_result',
             tool_use_id: call.id,
-            content: typeof result === 'string' ? result : JSON.stringify(result),
+            content: toolResultContentForCall(call.name, result),
             ...(isError ? { isError: true } : {}),
           });
         }
@@ -11245,7 +11313,8 @@ export async function streamLLMWithTools(
     // synthesis attempt. Extended to gemini 2026-05-04 alongside
     // W5-E/W5-F for the same pathology shape.
     if (
-      !forceSynthesisAttempted
+      !opts.researchTurn
+      && !forceSynthesisAttempted
       && noContentReadTurnStreak >= 4
       && (modelFamily === 'gemini'
         || applyCodexBehaviorGuard('force-synthesis', effectiveModel, codexGuardCandidate, true))
@@ -11500,6 +11569,7 @@ function makeOpenAICompatProvider(
         throw new Error(`${name} unavailable: configure apiKey via \`elanous setup\``);
       }
       const activeModel = opts.model || model;
+      if (getModelFamily(activeModel) === 'claude') assertNoTopLevelToolSchemaCombinators(opts.tools);
       const wireModel = name === 'openrouter' ? openRouterWireModel(activeModel) : activeModel;
       const tools = toOpenAITools(
         opts.tools,

package/src/loops/orchestrator/inbox-once.ts

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { resolveConfiguredAgentRoleLlm } from '../../user-config.js';
+import type { RoleLlmSpec } from '../../user-config.js';
+import { loadAgentRolePack } from '../agent-reply.js';
+import type { MsgStore } from '../../msg/msg-store.js';
+import { runAskOpContextInbox, runCoordinatorAgentInbox, type CoordinatorInboxResult } from './inbox.js';
+import type { AskOpContextBundle } from '../../context-bus/context-now.js';
+
+export interface InboxOnceOptions {
+  root?: string;
+  store?: MsgStore;
+  role?: RoleLlmSpec | null;
+  limit?: number;
+  context?: (question: string, options: { audience?: string; limit?: number }) => Promise<AskOpContextBundle>;
+}
+
+/** One scan of the same durable inbox as the orchestrator tick, without running its graph. */
+export async function runCoordinatorInboxOnce(options: InboxOnceOptions = {}): Promise<CoordinatorInboxResult> {
+  const root = options.root ?? effectiveInstanceRoot();
+  const path = join(root, 'msg', 'messages.db');
+  const role = options.role === undefined ? resolveConfiguredAgentRoleLlm('coordinator') : options.role;
+  if (role) return runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), root, path,
+    limit: options.limit ?? 100, ...(options.store ? { store: options.store } : {}) });
+  return runAskOpContextInbox({ path, limit: options.limit ?? 100,
+    ...(options.store ? { store: options.store } : {}),
+    ...(options.context ? { context: options.context } : {}) });
+}

package/src/loops/orchestrator/inbox.ts

@@ -1,15 +1,90 @@
+import { ASK_OP_COMMAND } from '../../session/channel-ask-op-envelope.js';
 import { openMsgStore, type Message, type MsgStore } from '../../msg/msg-store.js';
 import { classifySeatTrafficProposal } from '../../seat-loop/traffic-signal.js';
-import { debug } from '../../debug/log.js';
+import { debug, redactSecretText } from '../../debug/log.js';
 import { LOOP_MESSAGE_ROUTES } from '../msg-address.js';
 import { replyWithAgent, type AgentReplyInput } from '../agent-reply.js';
 import { knowhowAdvice, type KnowhowAdvice, type KnowhowOptions } from './knowhow-pack.js';
 import type { RoleLlmSpec } from '../../user-config.js';
 import type { LLMProvider } from '../../llm.js';
+import { askOpContextBundle, type AskOpContextBundle } from '../../context-bus/context-now.js';
 
 const RECIPIENT = LOOP_MESSAGE_ROUTES.orchestrator.msgAddress;
 
 export interface CoordinatorInboxResult { replied: number; acknowledged: number }
+export interface AskOpTestHarness {
+  /** A test-only sink; this never defaults to a real surface transport. */
+  replySink: (reply: { from: string; to: string; body: string; kind: 'reply'; replyTo: number }) => Message;
+  /** Capture both clocks without writing to the production log store in tests. */
+  eventSink?: (event: { requestId: number; requestToReplyMs: number | null; processingMs: number }) => void;
+}
+export interface AskOpContextInboxOptions {
+  store?: MsgStore;
+  path?: string;
+  limit?: number;
+  context?: typeof askOpContextBundle;
+  knowhow?: KnowhowOptions | false;
+  /** Only the ordered tick scan may advance the durable cursor. */
+  acknowledge?: boolean;
+  /** SSE delivery handles exactly its message; the ordered tick scans the cursor. */
+  request?: Message;
+  /** Explicit opt-in for synthetic TEST ASK-OP questions only. Production callers must omit this. */
+  testHarness?: AskOpTestHarness;
+}
+
+const ASK_OP_SENDERS = new Set(['TELEGRAM', 'DISCORD']);
+const REFUSE = '모름 — 확인된 근거가 없어 답할 수 없습니다.';
+
+function isAskOpRequest(request: Message, allowTestSource = false): boolean {
+  const testSource = allowTestSource && request.from === 'TEST'
+    && /^Test \/(?:askop|ask-op)(?:\r?\n|$)/.test(request.body);
+  return request.kind === 'question' && (ASK_OP_SENDERS.has(request.from) || testSource)
+    && (testSource || new RegExp(`^(?:Telegram|Discord) \/(?:${ASK_OP_COMMAND}|ask-op)(?:\\r?\\n|$)`).test(request.body));
+}
+
+function askOpLatencyMs(request: Message, repliedAt: number): number | null {
+  const createdAt = Date.parse(request.createdAt);
+  const latencyMs = repliedAt - createdAt;
+  return Number.isFinite(createdAt) && latencyMs >= 0 ? latencyMs : null;
+}
+
+function writeAskOpReply(store: MsgStore, request: Message, replyText: string, options: AskOpContextInboxOptions) {
+  if (options.testHarness && request.from === 'TEST') {
+    const marker = `re #${request.id}\n`;
+    const body = replyText.startsWith(marker) ? replyText.slice(marker.length) : replyText;
+    const reply = options.testHarness.replySink({ from: RECIPIENT, to: request.from,
+      body, kind: 'reply', replyTo: request.id });
+    return { id: reply.id, posted: true };
+  }
+  return writeCoordinatorReply(store, request, replyText);
+}
+
+function askOpQuestion(request: Message): string {
+  const match = /^question: (.*)$/m.exec(request.body);
+  return match?.[1]?.trim() ?? '';
+}
+
+function unsafeAskOp(question: string): boolean {
+  // Reject explicit commands, not descriptive questions such as "What changed since the release?".
+  return /^(?:(?:please|can you|could you|would you)\s+)?(?:run|execute|deploy|publish|push|merge|delete|drop|write|edit|change|set)\b|(?:실행해|발행해|배포해|푸시해|병합해|삭제해|수정해|바꿔|설정해)(?:줘|주세요)?|\b(?:show|reveal|give|tell|display|print|read|open|what is|what's)\b.{0,80}\b(?:secret|token|password|credential|api[ -]?key|private[ -]?key)\b|(?:비밀|토큰|암호|패스워드|인증키|API\s*키).{0,80}(?:보여|알려|공개|읽어)/i.test(question);
+}
+
+async function askOpAnswer(request: Message, options: AskOpContextInboxOptions): Promise<string> {
+  const question = askOpQuestion(request);
+  if (!question) return `제안: ${REFUSE}\n근거: 질문이 비었습니다.`;
+  if (unsafeAskOp(question)) return '제안: 요청한 권한 실행·비밀 조회·traffic/칸 변경은 실행할 수 없습니다.\n근거: OP 질문 답변은 읽기 전용입니다.';
+  let bundle: AskOpContextBundle;
+  // These replies are delivered to an external channel, not the private operator console.
+  try { bundle = await (options.context ?? askOpContextBundle)(question, { audience: 'public-demo', limit: 8 }); }
+  catch { return `제안: ${REFUSE}\n근거: 맥락 조회 실패.`; }
+  const facts = bundle.facts.filter(fact => fact.source?.trim() && fact.summary?.trim()).slice(0, 8);
+  if (!facts.length) {
+    const gaps = bundle.gaps.slice(0, 3).map(gap => `${redactSecretText(gap.kind)}: ${redactSecretText(gap.reason)}`).join('; ');
+    return `제안: ${REFUSE}\n근거: ${gaps || '미관측'}.`;
+  }
+  const evidence = facts.map(fact => `- ${redactSecretText(fact.summary)} — ${redactSecretText(fact.source)} (관측 ${redactSecretText(fact.observedAt)})`).join('\n');
+  return `제안: 다음은 관측된 OP 맥락입니다 (${redactSecretText(bundle.topic)}; 조회 ${redactSecretText(bundle.queriedAt)}).\n근거:\n${evidence}\n판단·승인·실행은 하지 않았습니다.`;
+}
 export interface CoordinatorAgentInboxOptions {
   role: RoleLlmSpec;
   pack: string;
@@ -95,6 +170,57 @@ function writeCoordinatorReply(store: MsgStore, request: Message, replyText: str
   return { id: reply.id, posted: true };
 }
 
+/** Surface ask-op questions use the same linked reply and durable acknowledgement as the resident inbox. */
+export async function runAskOpContextInbox(options: AskOpContextInboxOptions = {}): Promise<CoordinatorInboxResult> {
+  const store = options.store ?? openMsgStore(options.path);
+  const ownStore = options.store === undefined;
+  const result = { replied: 0, acknowledged: 0 };
+  const acknowledge = options.acknowledge !== false;
+  try {
+    const requests = options.request ? [options.request]
+      : store.listByRecipient(RECIPIENT, store.getCursor(RECIPIENT), options.limit ?? 100);
+    for (const request of requests) {
+      if (request.to !== RECIPIENT || request.from === RECIPIENT ||
+        (request.kind !== undefined && request.kind !== 'request' && request.kind !== 'question')) {
+        if (acknowledge) { store.ack(RECIPIENT, request.id); result.acknowledged++; }
+        continue;
+      }
+      const testAskOp = request.from === 'TEST' && isAskOpRequest(request, true);
+      if (testAskOp && !options.testHarness) continue;
+      const key = `coord-inbox:${request.id}:${request.from}`;
+      const existing = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
+        .get(key) as { message_id: number } | null;
+      // Legacy seat traffic and knowhow requests preserve the existing answer path.
+      const startedAt = Date.now();
+      const replyText = existing ? '' : (isAskOpRequest(request, options.testHarness !== undefined)
+        ? `re #${request.id}\n${await askOpAnswer(request, options)}` : coordinatorReply(request, options.knowhow ?? {}));
+      const one = store.db.transaction(() => {
+        const receipt = store.db.query('SELECT message_id FROM msg_provenance WHERE provenance_key = ?')
+          .get(key) as { message_id: number } | null;
+        const reply = receipt ? { id: receipt.message_id, posted: false } : writeAskOpReply(store, request, replyText, options);
+        if (!receipt) store.db.query('INSERT INTO msg_provenance(provenance_key, message_id) VALUES (?, ?)').run(key, reply.id);
+        if (acknowledge) store.ack(RECIPIENT, request.id);
+        return reply.posted;
+      }).immediate();
+      if (one) result.replied++;
+      if (acknowledge) result.acknowledged++;
+      debug.log('loop.coordinator-inbox', 'reply', { requestId: request.id, recipient: request.from, duplicate: !one });
+      if (one && isAskOpRequest(request, options.testHarness !== undefined)) {
+        const repliedAt = Date.now();
+        const latencyMs = askOpLatencyMs(request, repliedAt);
+        const processingMs = Math.max(0, repliedAt - startedAt);
+        if (options.testHarness && request.from === 'TEST') {
+          options.testHarness.eventSink?.({ requestId: request.id, requestToReplyMs: latencyMs, processingMs });
+        } else {
+          debug.log('ask-op.inbox', 'replied', { requestId: request.id, requestToReplyMs: latencyMs,
+            processingMs, clockSkew: latencyMs === null });
+        }
+      }
+    }
+    return result;
+  } finally { if (ownStore) store.close(); }
+}
+
 /** One transaction ties a reply to its acknowledgement. A retry finds the durable receipt. */
 export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: string,
   options: CoordinatorInboxOptions = {}): CoordinatorInboxResult {
@@ -144,6 +270,9 @@ export async function handleCoordinatorAgentMessage(
   const ownStore = input.store === undefined;
   const acknowledge = input.acknowledge === true;
   try {
+    if (isAskOpRequest(request) && request.to === RECIPIENT) {
+      return await runAskOpContextInbox({ store, request, acknowledge });
+    }
     if (request.to !== RECIPIENT || request.from === RECIPIENT ||
       (request.kind !== undefined && request.kind !== 'request' && request.kind !== 'question')) {
       if (acknowledge) store.ack(RECIPIENT, request.id);

package/src/loops/orchestrator/tick.ts

@@ -25,7 +25,7 @@ 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';
@@ -97,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. */
@@ -521,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);

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/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 배달,