elanous 0.2.6 → 0.2.8

package/src/discord.ts

@@ -23,6 +23,8 @@
 import { markdownToTelegramHtml as _unusedMarkdownFn } from './telegram-format.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
 import { debug } from './debug/log.js';
 import { getUserConfig } from './user-config.js';
+import { handleDiscordSeatWork, type DiscordSeatWorkDeps } from './intake-plane/discord-seat-work.js';
+import { parseSeatAddress } from './seat-address/seat-address.js';
 
 // Telegram's HTML markdown isn't directly useful for Discord (Discord
 // uses CommonMark + its own subset). Import kept as a reminder that
@@ -163,6 +165,8 @@ export interface DiscordBotOpts {
    *  primary `onMessage` LLM chat path. Errors are swallowed by the
    *  caller — this is a best-effort fan-out. */
   onTriggerTap?: (event: DcTriggerEvent) => void | Promise<void>;
+  /** Override the intake door's dependencies for isolated Discord seat-work tests. */
+  seatWorkDeps?: DiscordSeatWorkDeps;
 }
 
 /** Surface-unification v2 — minimal trigger-side event shape. Maps
@@ -204,6 +208,8 @@ export class DiscordBot {
   private readonly token: string;
   private readonly allowedUsers: Set<string>;
   private readonly guildTextChannels: Set<string>;
+  /** The bot's own user id (from READY) — EV12c lets an allowlisted @mention open any guild channel. */
+  private selfUserId: string | undefined;
   private readonly onMessage: DcMessageHandler;
   private readonly maxChars: number;
   private readonly log: (msg: string) => void;
@@ -216,6 +222,7 @@ export class DiscordBot {
   private readonly onReaction: ((event: DcReactionEvent) => void | Promise<void>) | null;
   /** Surface-unification v2 (FU-1) — workflow-runtime tap. */
   private readonly onTriggerTap: ((event: DcTriggerEvent) => void | Promise<void>) | null;
+  private readonly seatWorkDeps: DiscordSeatWorkDeps;
   private ws: WebSocket | null = null;
   private running = false;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -239,6 +246,7 @@ export class DiscordBot {
     this.onInteraction = opts.onInteraction ?? null;
     this.onReaction = opts.onReaction ?? null;
     this.onTriggerTap = opts.onTriggerTap ?? null;
+    this.seatWorkDeps = opts.seatWorkDeps ?? {};
   }
 
   /** Send a raw payload on the gateway WebSocket. Voice adapter uses
@@ -490,6 +498,23 @@ export class DiscordBot {
     return r?.id ? { id: r.id } : null;
   }
 
+  /** DEC-TG — edit a message's text AND components (an empty list removes the buttons). */
+  async editMessageWithComponents(
+    channelId: string,
+    messageId: string,
+    text: string,
+    components: ReadonlyArray<Record<string, unknown>>,
+  ): Promise<void> {
+    const content = text.length > this.maxChars ? text.slice(0, this.maxChars - 4) + ' …' : text;
+    await this.restCall('PATCH', `/channels/${channelId}/messages/${messageId}`, { content, components });
+  }
+
+  /** DEC-TG — the DM channel id with one user (Discord returns the existing one when it already exists). */
+  async openDmChannel(userId: string): Promise<string | null> {
+    const r = await this.restCall<{ id?: string }>('POST', '/users/@me/channels', { recipient_id: userId });
+    return r?.id ?? null;
+  }
+
   // ── Gateway: connect + run forever ──────────────────────────
 
   /** Connect to the Gateway, identify, and process events until
@@ -604,6 +629,7 @@ export class DiscordBot {
             session_id?: string;
           };
           this.log(`READY — logged in as @${d.user?.username ?? '?'} (${d.user?.id ?? '?'})`);
+          if (d.user?.id) this.selfUserId = d.user.id;
           if (this.voiceTap?.onReady && d.session_id && d.user?.id) {
             try { this.voiceTap.onReady(d.session_id, d.user.id); }
             catch (err: any) { this.log(`voice tap onReady failed: ${err?.message ?? err}`); }
@@ -684,6 +710,20 @@ export class DiscordBot {
 
   // ── Message routing ────────────────────────────────────────
 
+  /** EV12c — true when this message @mentions the bot itself (mentions array or the raw `<@id>` token). */
+  private mentionsSelf(m: Record<string, unknown>, text: string): boolean {
+    const self = this.selfUserId;
+    if (!self) return false;
+    if (Array.isArray(m.mentions) && (m.mentions as Array<{ id?: unknown }>).some(u => String(u?.id) === self)) return true;
+    return text.includes(`<@${self}>`) || text.includes(`<@!${self}>`);
+  }
+
+  private stripSelfMention(text: string): string {
+    const self = this.selfUserId;
+    if (!self) return text;
+    return text.split(`<@!${self}>`).join('').split(`<@${self}>`).join('').replace(/\s+/g, ' ').trim();
+  }
+
   private async handleMessageCreate(m: Record<string, unknown>): Promise<void> {
     // Ignore bot's own messages (DM reply from our own send would
     // re-enter here).
@@ -692,19 +732,25 @@ export class DiscordBot {
 
     // DM-only v1 scope: guild_id is absent for DM channels.
     // Voice channel commands (`/voice-join`, `/voice-leave`,
-    // `/voice-status`) intentionally bypass DM-only — they need a
-    // guild context to operate. Everything else stays DM-routed so
-    // unrelated guild traffic doesn't reach the LLM path.
+    // `/voice-status`) and allowlisted, seat-addressed work bypass
+    // DM-only. All other guild traffic stays gated unless explicitly
+    // configured as a guild text channel.
     const isDm = !m.guild_id;
+    const rawText = typeof m.content === 'string' ? m.content : '';
+    const mentionsSelf = this.mentionsSelf(m, rawText);
     if (!isDm && !this.guildTextChannels.has(String(m.channel_id))) {
-      const trimmed = typeof m.content === 'string' ? m.content.trim() : '';
-      if (!/^\/voice-(join|leave|status)\b/.test(trimmed)) return;
+      if (!/^\/voice-(join|leave|status)\b/.test(rawText.trim())
+          && !(this.allowedUsers.has(author.id) && (parseSeatAddress(rawText) || mentionsSelf))) {
+        debug.log('discord.trigger', 'dropped', { reason: 'guild-not-chat', channelId: String(m.channel_id) });
+        return;
+      }
     }
 
     // Allowlist enforcement. An empty allowlist refuses everyone —
     // safer default than "open to the world" when the bot runs
     // with no user config.
     if (this.allowedUsers.size > 0 && !this.allowedUsers.has(author.id)) {
+      debug.log('discord.trigger', 'dropped', { reason: 'not-allowed', isDm });
       this.log(`discord: refusing unknown user ${author.id}`);
       try {
         await this.sendMessage(
@@ -738,7 +784,7 @@ export class DiscordBot {
       channelId: String(m.channel_id),
       userId: author.id,
       userName: author.username,
-      text: typeof m.content === 'string' ? m.content : '',
+      text: mentionsSelf ? this.stripSelfMention(rawText) : rawText,
       messageId: String(m.id),
       isDm,
       attachments,
@@ -790,6 +836,27 @@ export class DiscordBot {
       }
     }
 
+    // Addressed work is submitted only by configured owners; ordinary chat keeps its existing path.
+    if (this.allowedUsers.has(author.id) && parseSeatAddress(ctx.text)) {
+      const threadId = typeof m.thread_id === 'string' && m.thread_id ? m.thread_id : undefined;
+      const replyChannelId = threadId ?? ctx.channelId;
+      try {
+        const seatReply = await handleDiscordSeatWork(ctx.text, {
+          channelId: replyChannelId,
+          messageId: ctx.messageId,
+          ...(threadId ? { threadId } : {}),
+        }, this.seatWorkDeps);
+        if (seatReply !== null) {
+          await this.sendMessage(replyChannelId, seatReply);
+          return;
+        }
+      } catch (err: unknown) {
+        this.log(`discord seat work failed: ${err instanceof Error ? err.message : String(err)}`);
+        await this.sendMessage(replyChannelId, '좌석 요청을 접수하지 못했습니다. 잠시 후 다시 보내 주세요.');
+        return;
+      }
+    }
+
     // §C5 스트리밍 flip — streaming.discord ON 이면 옛 경로(placeholder+streamer+delivery) 억제,
     // 청크 fan-out sink 가 담당(handler chunkProducer 가 primarySurfaces=['discord']). 텔레그램 동형.
     const dcStreamingFlip = getUserConfig().sessionFabric?.streaming?.discord === true;

package/src/domains/core-tools.ts

@@ -15,6 +15,8 @@ import { existsSync } from 'node:fs';
 import { Database } from 'bun:sqlite';
 import type { LLMToolSpec } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { runRecall, type RecallSearch } from '../tool-runtime/self-cognition-runtimes.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { SCHEDULE_MANAGE_SPEC, dispatchScheduleManage } from './schedule-manage-tool.js';
 import { SESSION_MANAGE_SPEC, dispatchSessionQuery } from './session-query-tool.js';
 import { AUTOPILOT_MISSION_SPEC, dispatchAutopilotMissions } from '../autopilot/mission-tool.js';
@@ -43,6 +45,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
       sinceHours: { type: 'number', description: '조회 기간 시간(기본 168=7일).' },
       limit: { type: 'number', description: '반환 건수(기본 8).' },
       restoreId: { type: 'string', description: '느린 복원(선택) — archived 후보의 id 를 지정하면 그 cold 기억을 S3 에서 복원(recall_count++·warm 재활성화)해 본문 반환. 회상 결과 archived 에 관련 후보가 있고 본문이 필요할 때만.' },
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
     },
     required: [],
   },
@@ -50,7 +53,7 @@ const MEMORY_RECALL_SPEC: LLMToolSpec = {
 
 /** memory_recall 코어(db 주입·테스트 가능). restoreId 지정 시 느린 복원(축B P2), 아니면 회상 + archive 발견.
  *  recency+importance+relevance 스코어. restoreDeps 는 테스트 S3 mock(생략 시 기본 S3). */
-export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps): unknown {
+export function recallOrRestore(mdb: Database, args: Record<string, unknown>, restoreDeps?: ArchiveS3Deps, onPartial?: (result: Record<string, unknown>) => void): unknown {
   // ★ 축B P2 느린 복원 — restoreId 지정 시 cold 기억을 S3 에서 명시적 복원(recall_count++·warm 재활성화).
   //   자동 아님(명시적) = 복원 폭주 방지. 죽어있던 restoreFromArchive 호출부 배선.
   if (typeof args.restoreId === 'string' && args.restoreId) {
@@ -75,15 +78,17 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
     ...(typeof args.sinceHours === 'number' ? { sinceHours: args.sinceHours } : {}),
     ...(typeof args.limit === 'number' ? { limit: args.limit } : {}),
   });
+  const mappedHits = hits.map(h => ({
+    when: h.ts, surface: h.surface, kind: h.kind,
+    text: h.text.slice(0, 400), importance: h.importance,
+    score: Math.round(h.score * 1000) / 1000,
+  }));
+  onPartial?.({ hits: mappedHits, count: hits.length });
   // M2 — cold(S3 보관) 기억 메타 발견(본문 fetch 없음·빠름). 존재+id 알리고 복원은 restoreId 로 명시적.
   const q = typeof args.query === 'string' ? String(args.query) : '';
   const archived = q ? searchArchive(mdb, q, { ...(typeof args.domain === 'string' && args.domain ? { domain: String(args.domain) } : {}), limit: 3 }) : [];
   return {
-    hits: hits.map(h => ({
-      when: h.ts, surface: h.surface, kind: h.kind,
-      text: h.text.slice(0, 400), importance: h.importance,
-      score: Math.round(h.score * 1000) / 1000,
-    })),
+    hits: mappedHits,
     count: hits.length,
     ...(archived.length ? { archived: archived.map(a => ({ id: a.id, when: a.ts, summary: a.summary, note: 'cold·S3 보관(restoreId 로 느린 복원)' })) } : {}),
     note: '내가 발송/통지한 것의 원장 회상(크로스서피스 기억·hot/warm). archived=흐려져 S3 로 이관된 cold 기억(존재+id·본문은 restoreId 로 느린 복원). 비었으면 해당 기간 발송 없음.',
@@ -91,18 +96,18 @@ export function recallOrRestore(mdb: Database, args: Record<string, unknown>, re
 }
 
 /** memory_recall 공유 구현(finance-tools 에서 이관). db 열기 + recallOrRestore 위임. */
-async function dispatchMemoryRecall(args: Record<string, unknown>): Promise<unknown> {
+async function dispatchMemoryRecall(args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void): Promise<unknown> {
   if (!existsSync(surfaceEventsDbPath())) {
     return { hits: [], note: '발송 원장 미생성 — 아직 기록된 발송이 없음(데몬 재시작 후 sendOutbound부터 적재).' };
   }
   const mdb = openSurfaceEventsDb();
-  try { return recallOrRestore(mdb, args); }
+  try { return recallOrRestore(mdb, args, undefined, onPartial); }
   catch (e) { return { error: `기억 회상 실패: ${e instanceof Error ? e.message.slice(0, 100) : String(e)}` }; }
   finally { mdb.close(); }
 }
 
 /** L2 코어 앱 도구 dispatch 핸들러 — 이름 → 구현. 새 코어 도구는 여기 추가. */
-const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Promise<unknown>> = {
+const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void) => Promise<unknown>> = {
   schedule_manage: dispatchScheduleManage,
   session_manage: (args) => dispatchSessionQuery(args), // 대화 세션 검색·열람·목록·삭제(내용/ID/텔레그램)
   memory_recall: dispatchMemoryRecall,
@@ -115,26 +120,44 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>) => Prom
   mission_decide: dispatchMissionDecide, // 미션 결정 기록(re-ground·defer·boundary…)·3박자 주입·코어
 };
 
+/** Worker-side search entry: dispatch must not re-enter its own budget wrapper. */
+export function dispatchRecallUnbudgeted(name: 'memory_recall' | 'self_recall', args: Record<string, unknown>, onPartial: (result: Record<string, unknown>) => void): Promise<unknown> {
+  return CORE_TOOL_HANDLERS[name]!(args, onPartial);
+}
+
 /** L2 코어 앱 도구 spec 목록(전 서피스 공용). */
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
+const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
+  ...SELF_RECALL_SPEC,
+  parameters: {
+    ...SELF_RECALL_SPEC.parameters,
+    properties: {
+      ...(SELF_RECALL_SPEC.parameters.properties as Record<string, unknown>),
+      timeBudgetMs: { type: 'number', description: '기억 조회 시간 예산(밀리초·기본 60000). 초과 시 찾은 것까지 부분 반환.' },
+    },
+  },
+};
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
   names: Set<string>;
-  dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
+  dispatch: (name: string, args: Record<string, unknown>, onPartial?: (result: Record<string, unknown>) => void, context?: ToolRuntimeContext) => Promise<unknown>;
 }
 
 /** 서피스 무관 코어 앱 도구 세트. 모든 서피스가 이걸 조립 → 코어 도구 단일 출처 상속.
  *  L1(native)·L3(finance 팩)와 조합해 쓴다. dispatch 는 이름으로 라우팅(미등록=error). */
-export function buildCoreTools(): CoreTools {
+export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
   const names = new Set(CORE_TOOL_SPECS.map(s => s.name));
   return {
     specs: CORE_TOOL_SPECS,
     names,
-    dispatch: async (name, args) => {
+    dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
       if (!h) return { error: `unknown core tool: ${name}` };
-      return h(args);
+      if (name === 'memory_recall' || name === 'self_recall') {
+        return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
+      }
+      return h(args, onPartial);
     },
   };
 }

package/src/domains/outbound-alert.ts

@@ -6,7 +6,8 @@
 
 import * as childProcess from 'node:child_process';
 import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { conatusEnv } from './conatus-env.js';
 import { spillLongContent } from '../storage/content-spill.js';
@@ -17,6 +18,7 @@ import { resolveChannelBotToken } from '../channel-bot-token.js';
 import { kindRouteTarget } from './telegram-kind-route.js';
 import { debug } from '../debug/log.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 // ★ origin 되돌림(대표 2026-07-12) — 미션 알림을 발신 채널(메인 Q&A 봇)로 되돌린다. type-only
 //   import 라 런타임 순환 없음(발송 로직은 이 파일에 self-contained). origin 없으면 report 폴백.
 import type { MissionOrigin } from '../autopilot/mission-origin.js';
@@ -54,7 +56,7 @@ function recentSendBurst(): { recentCount: number; burst: boolean } {
 
 /** 발송 1건을 logs.db 에 관측(fail-open) — 발송 시각·mode·kind·밀림 판정. */
 function logSend(
-  mode: 'realtime' | 'deferred' | 'quiet-bypass' | 'flush',
+  mode: 'realtime' | 'quiet-bypass' | 'flush',
   kind: string,
   extra: Record<string, unknown> = {},
   opts?: { level?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'critical' },
@@ -111,15 +113,16 @@ export function userRecentlyActive(now: Date = new Date()): boolean {
 
 /** 야간 보류 적재 (jsonl append — 크론 동시 실행에 안전). origin 있으면 함께 적재 —
  *  아침 flush 가 그 origin(발신 채널)으로 되돌려 발송(없으면 report 묶음). */
-function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): void {
+function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
   try {
     mkdirSync(dirname(path), { recursive: true });
     const rec = { ts: new Date().toISOString(), kind, text, ...(origin ? { origin } : {}) };
     appendFileSync(path, JSON.stringify(rec) + '\n');
     console.error(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
-    logSend('deferred', kind, { reason: 'quiet-hours' });  // 밀림 적재 관측
+    return true;
   } catch (e) {
     console.error(`[outbound] 보류 적재 실패 — 콘솔 출력\n${text}`, e instanceof Error ? e.message : '');
+    return false;
   }
 }
 
@@ -139,8 +142,29 @@ function resolveBotToken(botId?: string): string | null {
   } catch { return null; }
 }
 
-/** origin(발신 채널)으로 직접 텔레그램 발송. telegram+chatId+토큰 해석 성공 시 true. */
+/** origin(발신 채널)으로 직접 발송. 실패하면 호출자가 report 폴백/재시도한다. */
 function deliverToOrigin(origin: MissionOrigin, text: string): boolean {
+  if (origin.channel === 'discord') {
+    if (!origin.channelId) return false;
+    try {
+      const token = resolveChannelBotToken('discord', getUserConfig())?.token;
+      if (!token) return false;
+      const channelId = origin.discordThreadId || origin.channelId;
+      const out = spillLongContent(text).text;
+      for (let start = 0; start < out.length;) {
+        let end = Math.min(start + 2000, out.length);
+        if (end < out.length && /[\uD800-\uDBFF]/.test(out[end - 1]!)) end--;
+        const response = curlPost(
+          `https://discord.com/api/v10/channels/${channelId}/messages`,
+          JSON.stringify({ content: out.slice(start, end) }),
+          [`Authorization: Bot ${token}`, 'Content-Type: application/json'],
+        );
+        if (typeof response?.id !== 'string' || !response.id) return false;
+        start = end;
+      }
+      return out.length > 0;
+    } catch { return false; }
+  }
   if (origin.channel !== 'telegram' || origin.chatId == null) return false;
   const token = resolveBotToken(origin.botId);
   if (!token) return false;
@@ -189,11 +213,13 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   // origin 없는 것 = report 묶음(기존 동작·finance/크론 알림).
   const noOrigin = items.filter(i => !i.origin);
   if (noOrigin.length && deliver(fmt(noOrigin), 'report')) delivered += noOrigin.length;
-  // ★ origin 있는 것 = 발신 채널(botId+chatId)별 묶음으로 되돌려 발송(미션 알림 → 메인 Q&A 봇).
+  // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
   for (const it of items) {
     if (!it.origin) continue;
-    const key = `${it.origin.botId ?? ''}:${it.origin.chatId ?? ''}`;
+    const key = it.origin.channel === 'discord'
+      ? JSON.stringify(['discord', it.origin.channelId, it.origin.discordThreadId ?? null])
+      : JSON.stringify([it.origin.channel, it.origin.botId ?? null, it.origin.chatId ?? null, it.origin.threadId ?? null]);
     if (!groups.has(key)) groups.set(key, { origin: it.origin, list: [] });
     groups.get(key)!.list.push(it);
   }
@@ -228,14 +254,26 @@ export function recordOutbound(text: string, kind: string): void {
 /** 발송 진입점 — 야간 무음 게이트(00:00~06:30 KST 보류) + 보류분 자동 플러시.
  *  origin(발신 채널) 이 주어지면 그 채널(메인 Q&A 봇 등)로 되돌려 발송 — 무음이면 origin 을
  *  함께 보류했다가 아침에 그 채널로 flush. origin 없거나 발송 실패 시 report 폴백(기존 동작). */
-export function sendOutbound(text: string, kind = 'alert', origin?: MissionOrigin | null): boolean {
+export function sendOutbound(text: string, kind = 'alert', origin?: (MissionOrigin & { surface?: string }) | null): boolean {
+  // Prefer the producer's surface; otherwise keep the caller's repository-relative path
+  // so two producers named index.ts cannot collapse into one sender.
+  const caller = new Error().stack?.split('\n')[2] ?? '';
+  const callerPath = caller.match(/(?:\(|\s)(file:\/\/[^\s()]+|\/[^\s()]+\.[cm]?[jt]s):\d+:\d+\)?/)?.[1];
+  const repoRoot = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+  const source = origin?.surface || (callerPath
+    ? relative(repoRoot, callerPath.startsWith('file://') ? fileURLToPath(callerPath) : callerPath).replace(/\\/g, '/')
+    : 'unknown');
+  const logOutcome = (event: 'sent' | 'deferred' | 'failed'): void => {
+    try { debug.log('outbound.send', event, { kind, source, chars: text.length }); } catch { /* fail-open */ }
+  };
   // ★ 무음 우회(대표 2026-07-14) — 사용자가 최근(기본 30분) genuine 인텐트(타이핑/버튼탭)를 냈으면
   //   깨어있으므로 야간 무음이어도 즉시 발송(사용자 발원 흐름의 결과물이 아침까지 묶이지 않게).
   //   우회 시 flushDeferred 로 그간 보류분도 함께 전달(사용자가 지금 볼 수 있음).
   if (inQuietHours() && !userRecentlyActive()) {
-    deferOutbound(text, kind, origin);
+    const queued = deferOutbound(text, kind, origin);
     recordOutbound(text, kind); // 보류도 논리적 발송 — 회상 대상(데몬 미경유라 클라 기록)
-    return true; // 보류 = 수락 (호출측 재시도/에러 루프 방지)
+    logOutcome(queued ? 'deferred' : 'failed');
+    return true; // 보류 시 수락 — 적재 오류에서도 기존 호출측 재시도 계약 유지
   }
   const bypass = inQuietHours();
   if (bypass) console.error('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
@@ -245,14 +283,16 @@ export function sendOutbound(text: string, kind = 'alert', origin?: MissionOrigi
   const { recentCount, burst } = recentSendBurst();
   logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, ...(burst ? { backlog: true } : {}) });
   // ★ origin 되돌림(무음 밖) — 발신 채널로 직접 발송. 성공 시 종료, 실패면 report 폴백.
-  if (origin && origin.channel === 'telegram' && origin.chatId != null && deliverToOrigin(origin, text)) {
+  if (origin && deliverToOrigin(origin, text)) {
     recordOutbound(text, kind);
+    logOutcome('sent');
     return true;
   }
   const path = deliver(text, kind);
   // 원장 기록은 정확히 1회. 데몬 경유(daemon)면 /v1/outbound 핸들러(outbound-report.ts)
   // 가 기록하므로 클라는 중복 금지 — 직접 폴백(direct·데몬 다운)만 클라가 기록.
   if (path === 'direct') recordOutbound(text, kind);
+  logOutcome(path === false ? 'failed' : 'sent');
   return path !== false;
 }
 
@@ -278,9 +318,31 @@ function logDaemonPath(classification: DaemonPathClass, kind: string, extra: Rec
   try { console.error(`[outbound] daemon-path ${classification}`); } catch { /* fail-soft */ }
 }
 
+/** OB8 — the daemon registers its own in-process sender at startup. Inside the daemon, deliver() must never curl
+ *  its own `/v1/outbound`: the curl is synchronous, the event loop that would answer it is the one it blocks, and the
+ *  whole daemon freezes until the curl times out (~25 s · `unreachable`) — the message is lost (CS1 · 10-01). */
+export type InProcessOutbound = (text: string, kind: string) => Promise<boolean>;
+let inProcessOutbound: InProcessOutbound | null = null;
+export function setInProcessOutbound(send: InProcessOutbound | null): void { inProcessOutbound = send; }
+
 /** elanous `/v1/outbound` 우선 → 실패 시 텔레그램 직접. 성공 경로 반환(원장 중복방지용). */
 export function deliver(text: string, kind = 'alert'): 'daemon' | 'direct' | false {
+  // 0) inside the daemon — route in-process, asynchronously; the caller's synchronous answer is «accepted».
+  if (inProcessOutbound && process.env.SEND_VIA_ELANOUS !== '0') {
+    const send = inProcessOutbound;
+    void send(text, kind)
+      .then((ok) => {
+        logDaemonPath(ok ? 'ok' : 'rejected', kind, { inProcess: true });
+        if (!ok && sendTelegramDirect(text, kind)) recordOutbound(text, kind);
+      })
+      .catch((error: unknown) => {
+        logDaemonPath('rejected', kind, { inProcess: true, error: error instanceof Error ? error.message : String(error) });
+        if (sendTelegramDirect(text, kind)) recordOutbound(text, kind);
+      });
+    return 'daemon';
+  }
   // 1) elanous 단일 발송 지점(/v1/outbound) — 데몬이 팬아웃 + 원장 기록.
+  let daemonPath: DaemonPathClass | 'not-found' | 'disabled' = 'disabled';
   if (process.env.SEND_VIA_ELANOUS !== '0') {
     let token = '';
     try { if (existsSync(ACP_TOKEN_PATH)) token = readFileSync(ACP_TOKEN_PATH, 'utf-8').trim(); } catch { /* no token */ }
@@ -291,12 +353,32 @@ export function deliver(text: string, kind = 'alert'): 'daemon' | 'direct' | fal
       : null;
     const classification = classifyDaemonResponse(j);
     if (classification === 'ok') return 'daemon';
+    daemonPath = nexus ? classification : 'not-found';
     const extra: Record<string, unknown> = { hasToken: token.length > 0 };
     if (j && typeof j === 'object' && 'error' in (j as object)) extra.error = (j as { error?: unknown }).error;
     logDaemonPath(classification, kind, extra);
   }
   // 2) fallback: 텔레그램 sendMessage 직접(3900자 분할) — 데몬 미경유라 클라가 원장 기록.
-  return sendTelegramDirect(text, kind) ? 'direct' : false;
+  if (sendTelegramDirect(text, kind)) return 'direct';
+  reportUndeliverable(kind, daemonPath);
+  return false;
+}
+
+/** OB8b — both paths failed: say so loudly, with the universe this process resolved, instead of a silent false.
+ *  The usual cause (10-01 · MK): an ad-hoc `bun -e` or a script from a source tree resolves a cwd-derived test
+ *  universe, so it finds neither the production daemon nor the production bot token. */
+function reportUndeliverable(kind: string, daemonPath: DaemonPathClass | 'not-found' | 'disabled'): void {
+  let root = '?';
+  let universe: 'prod' | 'test' | '?' = '?';
+  try {
+    root = effectiveInstanceRoot();
+    universe = root === prodInstanceRoot() ? 'prod' : 'test';
+  } catch { /* the report still goes out */ }
+  try { debug.log('outbound.send', 'undeliverable', { kind, daemonPath, universe, root }); } catch { /* fail-soft */ }
+  const hint = universe === 'prod'
+    ? '운영 데몬이 떠 있는지 확인: elanous nexus show'
+    : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous ELANOUS_CONFIG_DIR=~/.elanous 를 준다';
+  try { console.error(`[outbound] ⛔ 못 보냄(${kind}) — 데몬 ${daemonPath} · 직접 발송도 실패(토큰 없음 또는 전송 실패) · 이 프로세스의 우주 ${universe} (${root}) · ${hint}`); } catch { /* fail-soft */ }
 }
 
 /** 텔레그램 raw 발송(토큰·chatId 명시) — spill + 3900자 분할(줄 경계). thread 지원. */

package/src/domains/repeated-failure.ts

@@ -79,7 +79,7 @@ export function explainFailure(group: RepeatedFailureGroup): string {
   // the first live tick saw it as `webterm.tabs` (list errors re-raise the socket close) and sent the generic line.
   if (group.area.startsWith('webterm.') && /^socket closed: #: auth_failed$/i.test(group.reason)) {
     // Same words as the PWA banners (🅞 #21591·#21602 · 🅕 #21599) so the alert and the screen say one thing.
-    return '이 기기(브라우저)에 소유자 토큰이 없거나 틀리거나 만료돼 데몬이 연결을 거절한다 — 이미 연결된 기기의 설정 › Connect token 에서 토큰을 만들어, 이 기기의 설정 › Daemon › Bearer token 칸(/app/settings/#bearer-token)에 붙인다';
+    return '이 기기(브라우저)에 소유자 토큰이 없거나 틀리거나 만료돼 데몬이 연결을 거절한다 — 이미 연결된 기기의 설정 › 연결 토큰 만들기 에서 토큰을 만들어, 이 기기의 설정 › 데몬 연결 › 연결 토큰 칸(/app/settings/#bearer-token)에 붙인다';
   }
   const span = Date.parse(group.lastTs) - Date.parse(group.firstTs);
   const minutes = Number.isFinite(span) ? Math.max(1, Math.ceil(span / 60_000)) : 10;