elanous 0.2.43 → 0.2.44

package/src/mcp/server.ts

@@ -29,6 +29,7 @@ import { buildCliAgentTools } from '../cli/agent-cli.js';
 import { getUserConfig } from '../user-config.js';
 import type { TokenScope } from '../auth/scope.js';
 import { filterToolsForScope, isToolAllowedForScope } from '../nexus/api/mcp-public-allowlist.js';
+import { normalizeRunId } from '../harness/harness-space.js';
 
 // ─── JSON-RPC shapes ─────────────────────────────────────────────
 
@@ -102,6 +103,30 @@ export interface McpServerContext {
   tokenScope?: TokenScope;
 }
 
+/** Accept only an already-safe run identifier from standard MCP params._meta. */
+function mcpRunId(params: Record<string, unknown> | undefined): string | undefined {
+  const meta = params?._meta;
+  if (!meta || typeof meta !== 'object' || Array.isArray(meta)) return undefined;
+  const value = (meta as Record<string, unknown>).elanousRunId;
+  if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,64}$/.test(value)) return undefined;
+  const normalized = normalizeRunId(value);
+  return normalized === value ? value : undefined;
+}
+
+function logAsideRunIdDrop(toolName: string, params: Record<string, unknown> | undefined): void {
+  const meta = params?._meta;
+  const raw = meta && typeof meta === 'object' && !Array.isArray(meta)
+    ? (meta as Record<string, unknown>).elanousRunId
+    : undefined;
+  const reason = typeof raw !== 'string'
+    ? 'missing-or-non-string'
+    : !/^[A-Za-z0-9_-]{1,64}$/.test(raw)
+      ? 'invalid-format'
+      : normalizeRunId(raw) !== raw ? 'not-normalized' : 'validation-rejected';
+  try { debug.log('mcp-server.aside', 'elanous-tool-call-run-id-dropped', { toolName, reason }); }
+  catch { /* observation must not block the caller */ }
+}
+
 /** Emit a `system.mcp.proxy_call` user-intent event for a single
  *  tool dispatch. Best-effort — sink failures swallowed upstream by
  *  `userIntentLogger.emit`, and the outer try/catch keeps the
@@ -177,8 +202,20 @@ export async function handleMcpRequest(
         const args = (req.params?.arguments as Record<string, unknown>) ?? {};
         const surface = ctx.surface ?? 'mcp';
         const rt = getToolRuntime(name);
+        const runId = ctx.clientName === 'aside' ? mcpRunId(req.params) : undefined;
+        if (ctx.clientName === 'aside' && !runId) logAsideRunIdDrop(name, req.params);
+        const asideReturn = runId !== undefined;
         const isExposedOnSurface = listToolRuntimes(surface).some(runtime => runtime.id === rt?.id);
         if (!rt || !isExposedOnSurface) {
+          if (asideReturn) {
+            try {
+              debug.log('mcp-server.aside', 'elanous-tool-call', { runId, toolName: name });
+              debug.log('mcp-server.aside', 'elanous-tool-result', {
+                runId, toolName: name, ok: false,
+                errorClass: rt ? 'tool_not_exposed' : 'unknown_tool',
+              });
+            } catch { /* observation must not block the caller */ }
+          }
           emitProxyCallIntent(name, ctx.origin, false, 'unknown_tool');
           return {
             ...base,
@@ -186,6 +223,10 @@ export async function handleMcpRequest(
           };
         }
         try {
+          if (asideReturn) {
+            try { debug.log('mcp-server.aside', 'elanous-tool-call', { runId, toolName: name }); }
+            catch { /* observation must not block the caller */ }
+          }
           const isMcpAgent = surface === 'mcp' && rt.id === 'agent';
           const agentArgs = isMcpAgent
             ? { ...args, run_in_background: args.run_in_background ?? true }
@@ -198,6 +239,7 @@ export async function handleMcpRequest(
           const out = await dispatchToolByName(name, agentArgs, {
             surface,
             ...(ctx.clientName ? { mcpClient: ctx.clientName } : {}),
+            ...(runId ? { runId } : {}),
             ...(agentTools ? {
               agentHostTools: agentTools.specs,
               agentCwd,
@@ -212,10 +254,22 @@ export async function handleMcpRequest(
               background: agentArgs.run_in_background === true,
             });
           }
+          if (asideReturn) {
+            const resultRecord = out && typeof out === 'object' ? out as Record<string, unknown> : {};
+            const toolOk = resultRecord.ok === false || resultRecord.isError === true
+              ? false
+              : resultRecord.ok === true ? true : null;
+            try { debug.log('mcp-server.aside', 'elanous-tool-result', { runId, toolName: name, ok: toolOk }); }
+            catch { /* observation must not block the caller */ }
+          }
           emitProxyCallIntent(name, ctx.origin, true);
           return { ...base, result: toMcpToolCallResult(out) };
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
+          if (asideReturn) {
+            try { debug.log('mcp-server.aside', 'elanous-tool-result', { runId, toolName: name, ok: false, errorClass: err instanceof Error ? err.name : 'unknown' }); }
+            catch { /* observation must not block the caller */ }
+          }
           emitProxyCallIntent(name, ctx.origin, false, msg);
           throw err;
         }

package/src/native-tool-catalog.ts

@@ -734,8 +734,8 @@ export const nativeToolCatalog: NativeToolCatalogEntry[] = [
   {
     id: 'elanous_linear_secretary',
     kind: 'other', aliases: ['ElanousLinearSecretary'], displayName: 'ElanousLinearSecretary',
-    description: 'Ground a request in repository evidence and create a Linear parent issue with 3–5 assigned subtasks. Requires an explicit due date and verified evidence. Uses the configured project unless the request contains `projectless=true` and exactly one explicit `teamKey=<KEY>` token; never guesses a destination, date or citation.',
-    promptSummary: '`elanous_linear_secretary` (ground and create a parent with 3–5 evidence-backed subtasks; team-only needs projectless=true plus one explicit teamKey=<KEY>)',
+    description: 'DEMO-only grounded Linear secretary. Create a dated evidence-backed parent with 3–5 subtasks, record a child progress/Done transition using actual intake records and approved browser evidence, or open one local pending approval per parent. Repeated approval calls return the existing card state; no external notifications are sent.',
+    promptSummary: '`elanous_linear_secretary` (DEMO create/progress/Done/evidence/approval; approval is local and sends nothing externally)',
     host: ['tui', 'mcp'], safety: ['mutating', 'network'], supportsParallel: false, defaultEnabled: true,
     intentScope: 'ops-fleet',
   },

package/src/nexus/api/consult-requests.ts

@@ -2,9 +2,10 @@ import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, re
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { debug } from '../../debug/log.js';
-import { sendTelegramReport } from '../../telegram-report.js';
-import { getUserConfig } from '../../user-config.js';
+import { getUserConfig, type UserConfig } from '../../user-config.js';
+import { roleForKind } from '../../domains/telegram-kind-route.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { routeOutbound, type RouterDeps } from '../outbound/router.js';
 import { jsonResponse } from './json-response.js';
 
 export const CONSULT_REQUESTS_PATH = '/v1/consult-requests';
@@ -27,6 +28,8 @@ export interface ConsultRequestsDeps {
    *  ⛔ Never `sendOutbound` here: it is a synchronous curl to this very daemon's `/v1/outbound`, so inside the
    *  daemon it blocks the event loop until it times out (~25 s · `unreachable`) and the alert is lost (CS1 · 10-01). */
   send?: (text: string, kind: string) => unknown;
+  /** In-process ChannelAdapter delivery seams for mock verification. */
+  routeDeps?: RouterDeps;
 }
 
 function file(root: string): string {
@@ -114,12 +117,21 @@ export async function handleConsultRequests(req: Request, deps: ConsultRequestsD
   const alert = `📮 상담 문의 ${entry.receiptId} · ${entry.name}(${entry.kind === 'personal' ? '개인' : (entry.org ?? '회사')}) · 관심 ${entry.interest}\n앱에서 보기`;
   // Fire and forget — the receipt is already on disk; the answer must not wait for the channel.
   void Promise.resolve()
-    .then(() => (deps.send ?? notifyInProcess)(alert, 'ops-alert'))
+    .then(() => deps.send ? deps.send(alert, 'ops-alert') : notifyInProcess(alert, 'ops-alert', deps.routeDeps))
     .catch((error: unknown) => { debug.log('consult.request', 'notify-failed', { receiptId: entry.receiptId, reason: error instanceof Error ? error.message : String(error) }); });
   return jsonResponse({ receiptId: entry.receiptId, receivedAt: entry.receivedAt }, 202);
 }
 
-async function notifyInProcess(text: string, kind: string): Promise<void> {
-  const delivered = await sendTelegramReport(getUserConfig(), text, { markdown: false, kind });
-  debug.log('consult.request', delivered ? 'notified' : 'notify-failed', { delivered, channels: [`telegram:${delivered ? 'ok' : 'fail'}`] });
+function telegramOnlyConfig(cfg: UserConfig, kind: string): UserConfig {
+  // Deliberately replace all outbound policy for this one notification: it must stay Telegram-only.
+  // The existing Telegram sender resolves credentials and chat targets from cfg.telegram.
+  return { ...cfg, raw: { ...cfg.raw, outbound: { channels: [{ type: 'telegram' }], routes: { [kind]: ['telegram'] } } } };
+}
+
+async function notifyInProcess(text: string, kind: string, routeDeps: RouterDeps = {}): Promise<void> {
+  const cfg = getUserConfig();
+  const route = await routeOutbound(telegramOnlyConfig(cfg, kind), { text, markdown: false, kind, role: roleForKind(cfg, kind) }, routeDeps);
+  debug.log('consult.request', route.delivered ? 'notified' : 'notify-failed', {
+    delivered: route.delivered, channels: route.channels.map(channel => `telegram:${channel.ok ? 'ok' : 'fail'}`),
+  });
 }

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

@@ -111,9 +111,9 @@ export function createDiscordTriggerLogger(
  *  DiscordEvent shape. The two were intentionally kept congruent
  *  (`src/discord.ts:160-172` comment) so the wire is a near-identity
  *  with `raw` carrying the full gateway payload for debugging. */
-export function toDiscordEvent(tap: DcTriggerEvent): DiscordEvent {
-  const envelope = receiveChannelEvent('discord', tap);
-  if (!envelope || envelope instanceof Promise) throw new Error('discord connector cannot normalize accepted tap');
+export async function toDiscordEvent(tap: DcTriggerEvent): Promise<DiscordEvent> {
+  const envelope = await receiveChannelEvent('discord', tap);
+  if (!envelope) throw new Error('discord connector cannot normalize accepted tap');
   return {
     kind: tap.kind,
     channel: envelope.channel ?? tap.channel,
@@ -136,10 +136,10 @@ export function buildDiscordTriggerTap(
   return (tap: DcTriggerEvent): void => {
     // Fire-and-forget — workflow dispatch errors are surfaced via the
     // workflow daemon's lifecycle bus, not the gateway loop. Any
-    // synchronous throw lands here so the chat reply (no-op in this
-    // bot) keeps flowing.
+    // normalization and dispatch rejections land here so the gateway
+    // loop and other accepted taps keep flowing.
     void Promise.resolve()
-      .then(() => dispatch(toDiscordEvent(tap)))
+      .then(async () => dispatch(await toDiscordEvent(tap)))
       .catch((err: unknown) => {
         const reason = err instanceof Error ? err.message : String(err);
         log(`workflow dispatch failed: ${reason}`);

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

@@ -207,11 +207,13 @@ function detailOf(id: string, source: 'core' | 'mine', editable: boolean, dir: s
       const group = (node as { group?: unknown }).group;
       return { node_id: nodeId, kind, recipe, max_visits: maxVisits, ...(typeof group === 'string' && group.trim() ? { group: group.trim() } : {}) };
     }),
-    edges: spec.edges.map(({ from, to, on, map }) => ({
+    edges: spec.edges.map(({ from, to, on, map, branches, join }) => ({
       from,
       ...(to === undefined ? {} : { to }),
       ...(on === undefined ? {} : { on }),
       ...(map === undefined ? {} : { map }),
+      ...(branches === undefined ? {} : { branches }),
+      ...(join === undefined ? {} : { join }),
     })),
   });
 }
@@ -287,7 +289,7 @@ export function handleGraphsGet(pathname: string, dir = defaultGraphsDir(), deps
           terminal_nodes: flat.terminalNodes,
           graph_hash: graphVersionHash(flat),
           nodes: flat.nodes.map(({ nodeId, kind, recipe, maxVisits }) => ({ node_id: nodeId, kind, recipe, max_visits: maxVisits })),
-          edges: flat.edges.map(({ from, to, on, map, fallback }) => ({ from, ...(to === undefined ? {} : { to }), ...(on === undefined ? {} : { on }), ...(map === undefined ? {} : { map }), ...(fallback === undefined ? {} : { fallback }) })),
+          edges: flat.edges.map(({ from, to, on, map, fallback, branches, join }) => ({ from, ...(to === undefined ? {} : { to }), ...(on === undefined ? {} : { on }), ...(map === undefined ? {} : { map }), ...(fallback === undefined ? {} : { fallback }), ...(branches === undefined ? {} : { branches }), ...(join === undefined ? {} : { join }) })),
         });
       } catch (error) {
         return jsonResponse({ error: 'unit-flatten-failed', id, message: error instanceof Error ? error.message : String(error) }, 422);

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

@@ -0,0 +1,206 @@
+import { spawn } from 'node:child_process';
+import { debug } from '../../debug/log.js';
+import { receiveChannelEvent } from '../outbound/router.js';
+import { registerGrokbotAdapter } from '../outbound/grokbot-adapter.js';
+import { createSession, listSessions } from '../../session/index.js';
+import type { UserConfig } from '../../user-config.js';
+import type { runTurn } from '../../session/chat.js';
+import type { ChannelEnvelope } from '../outbound/router.js';
+
+const DEFAULT_AGENT = 'COO';
+const DEFAULT_POLL_INTERVAL_MS = 15_000;
+const MAX_MESSAGE_BYTES = 64 * 1024;
+
+export interface GrokbotPendingMessage {
+  id: string;
+}
+
+export interface GrokbotMailbox {
+  listPending(): Promise<GrokbotPendingMessage[]>;
+  /** Atomically move a pending request into processing; null means another consumer claimed it. */
+  claim(id: string): Promise<string | null>;
+  acknowledge(id: string, text: string): Promise<void>;
+  complete(id: string, text: string): Promise<void>;
+  sendPrompt(agent: string, prompt: string): Promise<{ preview?: string }>;
+}
+
+export interface NexusGrokbotTriggerBotOptions {
+  mailbox: GrokbotMailbox;
+  dispatch: (event: ChannelEnvelope) => Promise<string>;
+  pollIntervalMs?: number;
+  now?: () => string;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+const GROKBOT_SESSION_CHAT_ID = -707151151;
+const GROKBOT_SESSION_BOT_ID = 'grokbot-coo';
+
+function grokbotMainSessionId(): string {
+  const existing = listSessions().find((session) => session.origin === 'grokbot' && session.personaId === 'grokbot-coo');
+  if (existing) return existing.id;
+  return createSession({
+    source: 'cli', sourceKind: 'telegram', origin: 'grokbot', personaId: 'grokbot-coo',
+    title: 'Grok Bot COO · 주 세션',
+  }).id;
+}
+
+/** Reuse one durable main-agent session for the bot's conversation across requests and restarts. */
+export function createGrokbotMainSessionDispatcher(
+  userConfig: UserConfig,
+  runTurnImpl: typeof runTurn,
+  getSessionId: () => string = grokbotMainSessionId,
+): (event: ChannelEnvelope) => Promise<string> {
+  const sessionId = getSessionId();
+  return async (event) => {
+    const result = await runTurnImpl({
+      userConfig,
+      sessionId,
+      userText: event.text,
+      utteranceSurface: 'telegram',
+      tgChat: { botId: GROKBOT_SESSION_BOT_ID, chatId: GROKBOT_SESSION_CHAT_ID },
+    });
+    return result.text;
+  };
+}
+
+export interface NexusGrokbotTriggerBotHandle {
+  pollOnce(): Promise<void>;
+  start(): void;
+  stop(): Promise<void>;
+}
+
+function safeReason(error: unknown): string {
+  const text = error instanceof Error ? error.message : String(error);
+  return text.replace(/Bearer\s+\S+/gi, 'Bearer [redacted]').slice(0, 240);
+}
+
+function validId(id: string): boolean {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(id);
+}
+
+function runRemote(script: string, timeoutMs = 20_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('ssh', ['-o', 'BatchMode=yes', 'box@grbot-coo', 'bash -s'], { stdio: ['pipe', 'pipe', 'ignore'] });
+    let stdout = '';
+    const timeout = setTimeout(() => child.kill('SIGTERM'), timeoutMs);
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk: string) => { stdout += chunk; });
+    child.on('error', () => { clearTimeout(timeout); reject(new Error('grokbot transport unavailable')); });
+    child.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code === 0) resolve(stdout.trimEnd());
+      else reject(new Error('grokbot transport failed'));
+    });
+    child.stdin.end(script);
+  });
+}
+
+function encoded(value: string): string {
+  const bytes = Buffer.from(value, 'utf8');
+  if (bytes.byteLength > MAX_MESSAGE_BYTES) throw new Error('grokbot message exceeds 64 KiB');
+  return bytes.toString('base64');
+}
+
+function remoteWrite(relativePath: string, value: string): string {
+  if (!/^[A-Za-z0-9_./-]+$/.test(relativePath)) throw new Error('invalid grokbot output path');
+  const body = encoded(value);
+  const target = `"$HOME/${relativePath}"`;
+  return `set -eu\nmkdir -p "$(dirname ${target})"\nprintf '%s' '${body}' | base64 -d > ${target}\n`;
+}
+
+/** SSH-only transport to the COO bot host. The gateway credential remains on that host. */
+export function createSshGrokbotMailbox(): GrokbotMailbox {
+  return {
+    async listPending() {
+      const output = await runRemote(`set -eu\nfor f in "$HOME"/elanous-inbox/*.txt; do\n  [ -f "$f" ] || continue\n  b=\${f##*/}; printf '%s\\n' "\${b%.txt}"\ndone\n`);
+      return output.split('\n').filter(validId).map((id) => ({ id }));
+    },
+    async claim(id) {
+      if (!validId(id)) throw new Error('invalid grokbot request id');
+      const output = await runRemote(`set -eu\nroot="$HOME/elanous-inbox"\nmkdir -p "$root/processing"\nsrc="$root/${id}.txt"\ndst="$root/processing/${id}.txt"\n[ -f "$src" ] || exit 3\n[ ! -e "$dst" ] || exit 4\nmv "$src" "$dst"\nbase64 "$dst" | tr -d '\\n'\n`);
+      return Buffer.from(output, 'base64').toString('utf8');
+    },
+    async acknowledge(id, text) {
+      if (!validId(id)) throw new Error('invalid grokbot request id');
+      await runRemote(`${remoteWrite(`elanous-outbox/${id}.ack`, text)}printf '%s\\n' "$(date -Is)" >> "$HOME/elanous-inbox/processing/${id}.accepted"\n`);
+    },
+    async complete(id, text) {
+      if (!validId(id)) throw new Error('invalid grokbot request id');
+      await runRemote(`${remoteWrite(`elanous-outbox/${id}.md`, text)}mkdir -p "$HOME/elanous-inbox/done"\nif [ -f "$HOME/elanous-inbox/processing/${id}.txt" ]; then mv "$HOME/elanous-inbox/processing/${id}.txt" "$HOME/elanous-inbox/done/${id}.txt"; fi\n`);
+    },
+    async sendPrompt(agent, prompt) {
+      if (agent !== DEFAULT_AGENT) throw new Error('grokbot agent is not allowlisted');
+      const body = encoded(prompt);
+      const script = `set -eu\ntoken=$(jq -er '.token | strings | select(length > 0)' "$HOME/sand-data/gateway.json")\nagent=$(curl -fsS -m 15 -X POST http://127.0.0.1:1340/api/listAgents -H 'Content-Type: application/json' -H "Authorization: Bearer $token" -d '{}' | jq -er '.[] | select(.name == "COO") | .id' | head -n 1)\n[ -n "$agent" ]\nprintf '%s' '${body}' | base64 -d | jq -Rs --arg agentId "$agent" '{agentId:$agentId,prompt:.}' | curl -fsS -m 30 -X POST http://127.0.0.1:1340/api/sendPrompt -H 'Content-Type: application/json' -H "Authorization: Bearer $token" --data-binary @- | jq -c '{preview:(.lastMessagePreview // .preview // "")}'\n`;
+      const response = await runRemote(script, 45_000);
+      const parsed = JSON.parse(response) as { preview?: unknown };
+      return { ...(typeof parsed.preview === 'string' && parsed.preview ? { preview: parsed.preview } : {}) };
+    },
+  };
+}
+
+export function createNexusGrokbotTriggerBot(options: NexusGrokbotTriggerBotOptions): NexusGrokbotTriggerBotHandle {
+  const now = options.now ?? (() => new Date().toISOString());
+  const log = options.log ?? ((event, data) => debug.log('channel.grokbot', event, data));
+  const unregister = registerGrokbotAdapter({
+    sendPrompt: (agent, prompt) => options.mailbox.sendPrompt(agent, prompt),
+    now,
+    log,
+  });
+  let stopped = false;
+  let polling = false;
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let currentPoll: Promise<void> | undefined;
+
+  const pollOnce = async (): Promise<void> => {
+    if (stopped || polling) return currentPoll;
+    polling = true;
+    currentPoll = (async () => {
+      try {
+        const messages = await options.mailbox.listPending();
+        for (const { id } of messages) {
+          if (stopped) break;
+          let text: string | null;
+          try { text = await options.mailbox.claim(id); }
+          catch (error) { log('failure', { id, failedAt: now(), reason: safeReason(error), stage: 'claim' }); continue; }
+          if (text === null) continue;
+          try {
+            const kind = /^(승인|보류|수정)(?:\s|[:：]|$)/.test(text.trim()) ? 'decision' : 'request';
+            const envelope = await receiveChannelEvent('grokbot', { id, text, kind });
+            if (!envelope || envelope instanceof Promise) throw new Error('grokbot request normalization failed');
+            await options.mailbox.acknowledge(id, 'OP 접수 — 답을 준비 중입니다.');
+            const reply = await options.dispatch(envelope);
+            if (!reply.trim()) throw new Error('main session returned an empty reply');
+            await options.mailbox.complete(id, reply);
+            log('reply', { id, repliedAt: now(), replyChars: reply.length });
+          } catch (error) {
+            const reason = safeReason(error);
+            log('failure', { id, failedAt: now(), reason, stage: 'dispatch-or-reply' });
+            try { await options.mailbox.complete(id, '요청을 처리하지 못했습니다. 주 세션 연결과 eln logs의 channel.grokbot 기록을 확인해 주세요.'); }
+            catch (replyError) { log('failure', { id, failedAt: now(), reason: safeReason(replyError), stage: 'failure-reply' }); }
+          }
+        }
+      } catch (error) {
+        log('failure', { failedAt: now(), reason: safeReason(error), stage: 'poll' });
+      }
+    })().finally(() => { polling = false; });
+    return currentPoll;
+  };
+
+  return {
+    pollOnce,
+    start() {
+      if (stopped || timer) return;
+      void pollOnce();
+      timer = setInterval(() => { void pollOnce(); }, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+      timer.unref?.();
+    },
+    async stop() {
+      stopped = true;
+      if (timer) clearInterval(timer);
+      timer = undefined;
+      await currentPoll;
+      unregister();
+    },
+  };
+}

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

@@ -123,9 +123,9 @@ export function createTelegramTriggerLogger(
  *  TelegramEvent shape. Congruent fields (`src/telegram.ts:166-180`
  *  comment) so the wire is a near-identity with `raw` carrying the
  *  full payload (messageId · isDm) for debugging. */
-export function toTelegramEvent(tap: TgTriggerEvent): TelegramEvent {
-  const envelope = receiveChannelEvent('telegram', tap);
-  if (!envelope || envelope instanceof Promise) throw new Error('telegram connector cannot normalize accepted tap');
+export async function toTelegramEvent(tap: TgTriggerEvent): Promise<TelegramEvent> {
+  const envelope = await receiveChannelEvent('telegram', tap);
+  if (!envelope) throw new Error('telegram connector cannot normalize accepted tap');
   return {
     kind: tap.kind,
     chat: envelope.channel ?? tap.chat,
@@ -149,10 +149,10 @@ export function buildTelegramTriggerTap(
   return (tap: TgTriggerEvent): void => {
     // Fire-and-forget — workflow dispatch errors surface via the
     // workflow daemon's lifecycle bus, not the polling loop. Any
-    // synchronous throw lands here so the chat reply (no-op in this
-    // bot) keeps flowing.
+    // normalization and dispatch rejections land here so the polling
+    // loop and other accepted taps keep flowing.
     void Promise.resolve()
-      .then(() => dispatch(toTelegramEvent(tap)))
+      .then(async () => dispatch(await toTelegramEvent(tap)))
       .catch((err: unknown) => {
         const reason = err instanceof Error ? err.message : String(err);
         log(`workflow dispatch failed: ${reason}`);

package/src/nexus/boot/register-mcp-clients.ts

@@ -28,7 +28,7 @@
 //     daemon exit.
 
 import type { McpServerSpec } from '../../user-config.js';
-import { McpClient, McpConnectionError, type McpTool, type McpToolCallResult } from '../../mcp/client.js';
+import { McpClient, McpConnectionError, type McpCallMeta, type McpTool, type McpToolCallResult } from '../../mcp/client.js';
 import {
   createMcpProxyRuntime,
   createMcpToolAuthorizer,
@@ -41,7 +41,8 @@ import { listNodeKinds } from '../../graph-kinds/registry.js';
 import { syncInstalledPluginNodes } from '../../graph-kinds/installed-plugin-nodes.js';
 import { listInstalledPlugins } from '../../plugins/install/plugin-install.js';
 import { pluginEnv, credentialStatus } from '../../plugins/install/plugin-credentials.js';
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { getHarnessRunId } from '../../harness/harness-space.js';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
 
 export interface McpClientsHandle {
@@ -143,6 +144,8 @@ export interface RegisterMcpClientsOpts {
   toolIndexStore?: McpToolIndexStore;
   /** `lazy` 자식의 SIGTERM→SIGKILL 유예(ms). 기본 2500 — 종료 3초 계약 안쪽. */
   lazyShutdownGraceMs?: number;
+  /** BROWSER-ROUNDTRIP-ASIDE test seam; production defaults to the state-root JSONL ledger. */
+  asideLedger?: AsideRoundtripLedger;
 }
 
 /** 한 서버가 지난 부팅에서 알린 툴 목록. `mcp-tool-index.json` 의 값. */
@@ -156,6 +159,77 @@ export interface McpToolIndexStore {
 
 export const MCP_TOOL_INDEX_FILENAME = 'mcp-tool-index.json';
 
+export interface AsideRoundtripEntry {
+  runId: string;
+  phase: 'call' | 'result';
+  toolName: string;
+  /** null means the caller did not provide a reason; do not invent one. */
+  reason: string | null;
+  at: string;
+  ok?: boolean;
+  classification?: string;
+  outputLength?: number;
+  errorClass?: string;
+}
+
+export interface AsideRoundtripLedger {
+  append(entry: AsideRoundtripEntry): void;
+  list(runId: string): AsideRoundtripEntry[];
+}
+
+const ASIDE_RUN_LEDGER_FILENAME = 'aside-run-roundtrip.jsonl';
+
+/** Persist only the run join and result receipt metadata, never prompt/result contents. */
+export function defaultAsideRoundtripLedger(root: string = elanousStateRoot()): AsideRoundtripLedger {
+  const file = join(root, ASIDE_RUN_LEDGER_FILENAME);
+  return {
+    append(entry) {
+      try {
+        mkdirSync(root, { recursive: true });
+        appendFileSync(file, `${JSON.stringify(entry)}\n`, 'utf8');
+      } catch (error) {
+        try { debug.log('mcp-client.aside', 'ledger-append-failed', { errorClass: error instanceof Error ? error.name : 'unknown' }); }
+        catch { /* a ledger failure must not block the MCP call */ }
+      }
+    },
+    list(runId) {
+      try {
+        return readFileSync(file, 'utf8').split('\n').flatMap((line) => {
+          if (!line.trim()) return [];
+          try {
+            const row = JSON.parse(line) as AsideRoundtripEntry;
+            return row && row.runId === runId && (row.phase === 'call' || row.phase === 'result') ? [row] : [];
+          } catch { return []; }
+        });
+      } catch { return []; }
+    },
+  };
+}
+
+function asideReason(args: Record<string, unknown>): string | null {
+  const raw = args.reason;
+  return typeof raw === 'string' && raw.trim().length > 0
+    ? redactSecretText(raw.trim()).slice(0, 240)
+    : null;
+}
+
+function asidePrompt(args: Record<string, unknown>, runId: string, reason: string | null): Record<string, unknown> {
+  if (typeof args.prompt !== 'string') return args;
+  const joinLine = `elanous 런 ${runId} · 결과는 elanous 도구로 돌려라.`;
+  if (args.prompt.includes(joinLine)) return args;
+  const instructions = [
+    joinLine,
+    ...(reason ? [`Delegation reason: ${reason}.`] : []),
+    'Use TaskGet to load this run’s task context, then return findings through Elanous MCP tools to the same runId. Keep browser credentials in the browser.',
+  ].join(' ');
+  return { ...args, prompt: `${instructions}\n\n${args.prompt}` };
+}
+
+function asideTextLength(result: McpToolCallResult): number {
+  return (result.content ?? []).reduce((length, block) =>
+    block.type === 'text' && typeof block.text === 'string' ? length + block.text.length : length, 0);
+}
+
 /** 지연 기동 자식의 정리 유예. `McpClient` 기본 5000ms 는 「SIGTERM 3초 안에
  *  안 끝남」이던 classic 종료 계약을 넘긴다 — 2500ms 면 SIGKILL 까지 3초 안쪽. */
 const DEFAULT_LAZY_SHUTDOWN_GRACE_MS = 2500;
@@ -209,11 +283,11 @@ class DeferredMcpClient implements DeferredInner {
     return this.inner.listTools();
   }
 
-  async callTool(name: string, args: Record<string, unknown>): Promise<McpToolCallResult> {
+  async callTool(name: string, args: Record<string, unknown>, meta?: McpCallMeta): Promise<McpToolCallResult> {
     await this.ensureStarted();
     // ⚠️ 기동 «뒤»의 inner.callTool 을 부른다 — 자격증명 마스킹 래퍼가
     //    createClient 직후 client.callTool 에 씌워지므로 그 래퍼를 탄다.
-    return this.inner.callTool(name, args);
+    return this.inner.callTool(name, args, meta);
   }
 
   async dispose(): Promise<void> {
@@ -259,6 +333,8 @@ export async function registerMcpClients(
   // A boot owns its ledger: same configured ids in concurrent/restarted boots
   // cannot inherit grants or revoke one another's authorization lifetime.
   const authorizer = createMcpToolAuthorizer();
+  let asideLedger = opts.asideLedger;
+  const asideLedgerFor = (): AsideRoundtripLedger => (asideLedger ??= defaultAsideRoundtripLedger());
   // FU3 (2026-05-13) — pipe McpClient lifecycle events into elanous's
   // keytrace logger so `mcp.client.spawn / .ready / .exit / .parse-error
   // / .stderr` all land in the daemon's debug log. Without this hook
@@ -420,14 +496,44 @@ export async function registerMcpClients(
     let client: McpClient | undefined;
     try {
       client = createClient(spec) as McpClient;
-      if (!opts.createClient && spec.transport === 'stdio') {
+      if (spec.transport === 'stdio' && (!opts.createClient || spec.id === 'aside')) {
         const originalCallTool = client.callTool.bind(client);
-        client.callTool = async (name: string, args: Record<string, unknown>): Promise<McpToolCallResult> => {
-          const values = injectedValuesByServer.get(spec.id) ?? [];
+        client.callTool = async (name: string, args: Record<string, unknown>, meta?: McpCallMeta): Promise<McpToolCallResult> => {
+          // Aside test clients use this same invocation boundary but bypass production credential injection.
+          const values = opts.createClient ? [] : injectedValuesByServer.get(spec.id) ?? [];
+          const isAsideExec = spec.id === 'aside' && name === 'exec';
+          const runId = isAsideExec ? (meta?.elanousRunId ?? getHarnessRunId()).trim() : '';
+          const reason = isAsideExec ? asideReason(args) : null;
+          const ledger = isAsideExec && runId ? asideLedgerFor() : undefined;
+          const now = () => new Date().toISOString();
+          const appendReceipt = (entry: AsideRoundtripEntry) => {
+            if (!ledger || !runId) return;
+            try { ledger.append(entry); } catch { /* bookkeeping must not block an MCP call */ }
+          };
+          const callArgs = isAsideExec && runId ? asidePrompt(args, runId, reason) : args;
+          if (isAsideExec && runId) {
+            try { debug.log('mcp-client.aside', 'exec-request', { runId, reason, toolName: name }); }
+            catch { /* observability is best-effort */ }
+            appendReceipt({ runId, phase: 'call', toolName: name, reason, at: now() });
+          }
           try {
-            const result = await originalCallTool(name, args);
+            const result = await originalCallTool(name, callArgs, meta);
+            if (isAsideExec && runId) {
+              const isError = result.isError === true;
+              const classification = isError ? 'mcp-server-error' : undefined;
+              const outputLength = asideTextLength(result);
+              appendReceipt({ runId, phase: 'result', toolName: name, reason, at: now(), ok: !isError, ...(classification ? { classification } : {}), outputLength });
+              try { debug.log('mcp-client.aside', 'exec-result', { runId, reason, toolName: name, ok: !isError, ...(classification ? { classification } : {}), isError, outputLength }); }
+              catch { /* observability is best-effort */ }
+            }
             return maskInjectedValues(result, values) as McpToolCallResult;
           } catch (err) {
+            if (isAsideExec && runId) {
+              const errorClass = err instanceof Error ? err.name : 'unknown';
+              appendReceipt({ runId, phase: 'result', toolName: name, reason, at: now(), ok: false, classification: 'mcp-transport-error', errorClass });
+              try { debug.log('mcp-client.aside', 'exec-error', { runId, reason, toolName: name, callToolRejected: true, errorClass }); }
+              catch { /* observability is best-effort */ }
+            }
             if (err instanceof Error) err.message = redactValues(err.message, values);
             else throw new Error(redactValues(String(err), values));
             throw err;