elanous 0.2.9 → 0.2.11

package/src/discord-self-message.ts

@@ -61,6 +61,9 @@ import { executionFooter } from './telegram-exec-footer.js';
 import { debug } from './debug/log.js';
 import { makeChunkProducer } from './session/streaming/chunk-producer.js';
 import { getUserConfig } from './user-config.js';
+import { detectCard, runCardFollowup, NotACardError } from './card-followup/core.js';
+import { localOcrText } from './telegram-card-followup.js';
+import type { runGraph } from './graph-runner/runner.js';
 
 const SLASH_FOCUS_TURNS_DEFAULT = 8;
 
@@ -135,6 +138,7 @@ export interface DiscordSelfMessageDeps {
    *  (legacy). */
   questionChannelFor?: (channelId: string) => import('./hitl/question.js').QuestionChannel;
   log?: (msg: string) => void;
+  cardFollowupDeps?: { ocrText?: (path: string) => Promise<string | null>; runGraph?: typeof runGraph; rootDir?: () => string };
 }
 
 /** Compose the full discord self+interweave onMessage handler. */
@@ -352,6 +356,34 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
     // Voice text commands pass the guild gate for the voice adapter's
     // sake — never route them into the LLM turn (legacy behavior).
     if (/^\/voice-(join|leave|status)\b/.test(ctx.text.trim())) return undefined;
+    if (!ctx.text.trim() && ctx.attachments.length === 1 && ctx.attachments[0]!.contentType?.startsWith('image/')) {
+      const photo = ctx.attachments[0]!;
+      if (detectCard({ width: photo.width, height: photo.height, ocrText: null }).decision !== 'skip') {
+        const bot = deps.getBot();
+        if (bot) {
+          let imagePath: string;
+          let ocrText: string | null;
+          try {
+            imagePath = (await bot.downloadAttachment(photo)).localPath;
+            ocrText = await (deps.cardFollowupDeps?.ocrText ?? localOcrText)(imagePath);
+          } catch {
+            return '명함을 읽지 못했습니다';
+          }
+          if (detectCard({ width: photo.width, height: photo.height, ocrText }).decision === 'card') {
+            try {
+              const result = await runCardFollowup({ imagePath, ocrText,
+                ...(deps.cardFollowupDeps?.runGraph ? { runGraph: deps.cardFollowupDeps.runGraph } : {}),
+                ...(deps.cardFollowupDeps?.rootDir ? { rootDir: deps.cardFollowupDeps.rootDir() } : {}),
+              });
+              for (const reply of result.replies) await bot.sendMessage(ctx.channelId, reply);
+              return streamer ? '명함 정리를 완료했습니다.' : undefined;
+            } catch (error) {
+              if (!(error instanceof NotACardError)) return '명함을 읽지 못했습니다';
+            }
+          }
+        }
+      }
+    }
     // S1 session commands (!sessions·!new·!attach) — before delegation
     // and self-turn routing, mirroring telegram's command precedence.
     const sessionReply = handleSessionCommand(ctx);

package/src/discord-slash-wire.ts

@@ -21,6 +21,7 @@ import { makeCommandRest } from './discord/slash-registry.js';
 import { normalizeInteractionPayload } from './discord/slash-router.js';
 import type { SlashCommandSchema } from './discord/slash-types.js';
 import { debug } from './debug/log.js';
+import { gateDiscordSchemas, readBotAudience } from './maturity/bot-command-maturity.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 
 const REST_BASE = 'https://discord.com/api/v10';
@@ -121,8 +122,11 @@ export function buildDiscordSlashWire(deps: DiscordSlashWireDeps): DiscordSlashW
     if (!app.id) { log('[slash] application id unresolved — skip'); return; }
     const guilds = await (await fetchImpl(`${REST_BASE}/users/@me/guilds`, auth)).json() as Array<{ id: string }>;
     const rest = makeCommandRest({ token, ...(deps.__fetchImpl ? { fetchImpl: deps.__fetchImpl } : {}) });
+    const audience = readBotAudience((deps.userConfig.raw?.discord as { commandAudience?: unknown } | undefined)?.commandAudience);
+    const { schemas, hidden } = gateDiscordSchemas(ELANOUS_SLASH_COMMANDS, audience);
+    debug.log('discord.command', 'menu-filtered', { total: ELANOUS_SLASH_COMMANDS.length, shown: schemas.length - hidden, ...audience });
     for (const g of Array.isArray(guilds) ? guilds : []) {
-      const registered = await rest.bulkOverwriteGuild(app.id, g.id, [...ELANOUS_SLASH_COMMANDS]);
+      const registered = await rest.bulkOverwriteGuild(app.id, g.id, schemas);
       log(`[slash] registered ${registered.length} commands in guild ${g.id}`);
     }
   }

package/src/discord.ts

@@ -23,6 +23,7 @@
 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 { deliverSeatAnswers } from './seat-dispatch/seat-ask.js';
 import { handleDiscordSeatWork, type DiscordSeatWorkDeps } from './intake-plane/discord-seat-work.js';
 import { parseSeatAddress } from './seat-address/seat-address.js';
 
@@ -226,6 +227,7 @@ export class DiscordBot {
   private ws: WebSocket | null = null;
   private running = false;
   private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private seatAskTimer: ReturnType<typeof setInterval> | null = null;
   private lastHeartbeatAck = true;
   private lastSeq: number | null = null;
 
@@ -246,7 +248,15 @@ export class DiscordBot {
     this.onInteraction = opts.onInteraction ?? null;
     this.onReaction = opts.onReaction ?? null;
     this.onTriggerTap = opts.onTriggerTap ?? null;
-    this.seatWorkDeps = opts.seatWorkDeps ?? {};
+    this.seatWorkDeps = { ...opts.seatWorkDeps, askDeps: {
+      ...opts.seatWorkDeps?.askDeps,
+      channel: 'discord',
+      send: opts.seatWorkDeps?.askDeps?.send ?? (async (origin, text) => {
+        if (origin.channel !== 'discord') throw new Error('seat ask belongs to another surface');
+        const posted = await this.sendMessage(origin.threadId ?? origin.channelId, text);
+        if (!posted) throw new Error('Discord seat ask reply was not posted');
+      }),
+    } };
   }
 
   /** Send a raw payload on the gateway WebSocket. Voice adapter uses
@@ -523,8 +533,12 @@ export class DiscordBot {
   async start(): Promise<void> {
     this.running = true;
     this.log(`discord bot starting (allowlist size ${this.allowedUsers.size})`);
+    this.seatAskTimer = setInterval(() => {
+      void deliverSeatAnswers(this.seatWorkDeps.askDeps!).catch((error) => this.log(`seat ask delivery failed: ${String(error)}`));
+    }, 10_000);
     while (this.running) {
       try {
+        await deliverSeatAnswers(this.seatWorkDeps.askDeps!);
         await this.runConnection();
       } catch (err: any) {
         this.log(`gateway error: ${err?.message ?? String(err)}`);
@@ -538,6 +552,8 @@ export class DiscordBot {
 
   stop(): void {
     this.running = false;
+    if (this.seatAskTimer) clearInterval(this.seatAskTimer);
+    this.seatAskTimer = null;
     if (this.ws) {
       try { this.ws.close(1000, 'client stop'); } catch { /* ignore */ }
       this.ws = null;
@@ -837,13 +853,14 @@ 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)) {
+    if (this.allowedUsers.has(author.id) && (parseSeatAddress(ctx.text) || (ctx.isDm && ctx.text && !ctx.text.startsWith('/')))) {
       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,
+          userId: ctx.userId, isDm: ctx.isDm,
           ...(threadId ? { threadId } : {}),
         }, this.seatWorkDeps);
         if (seatReply !== null) {

package/src/domains/coo-admin-tool.ts

@@ -0,0 +1,62 @@
+import type { LLMToolSpec } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { fetchLinearProjectIssues, type LinearProjectIssue } from '../connectors/linear.js';
+import { formatElanousCard } from './elanous-card.js';
+
+export const COO_ADMIN_SPEC: LLMToolSpec = {
+  name: 'coo_admin',
+  description: '읽기 전용 Linear COO 행정 조회 — «행정 뭐 남았어 · COO 할 일 · 마감 다가오는 행정» 질문에 사용. 외부 행정 프로젝트의 열린 일을 마감 순으로 읽는다.',
+  parameters: { type: 'object', properties: {}, required: [] },
+};
+
+export interface CooAdminDeps {
+  getSecret?: (id: string) => Promise<string | undefined>;
+  fetch?: typeof fetch;
+  project?: string;
+  now?: Date;
+}
+
+/** Reads the configured Linear project without changing any Linear issue. */
+export async function dispatchCooAdmin(_args: Record<string, unknown>, deps: CooAdminDeps = {}): Promise<string> {
+  let count = 0;
+  let overdue = 0;
+  try {
+    const apiKey = await (deps.getSecret ?? getSecretAsync)('connector.linear.apiKey');
+    if (!apiKey) {
+      debug.log('coo.admin', 'failed', { count, overdue, reason: 'missing-key' });
+      return 'Linear 키가 없습니다 — `elanous connector linear set-key`';
+    }
+    const project = deps.project ?? getUserConfig().coo?.linearProject ?? '외부 행정·큰 일 (COO)';
+    const issues = await fetchLinearProjectIssues({ apiKey, project, fetch: deps.fetch ?? fetch });
+    const today = deps.now ?? new Date();
+    const todayUtc = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
+    const daysUntil = (date: string) => Math.round((Date.parse(`${date.slice(0, 10)}T00:00:00Z`) - todayUtc) / 86_400_000);
+    issues.sort((a, b) => {
+      const deadlineOrder = a.dueDate == null ? (b.dueDate == null ? 0 : 1)
+        : b.dueDate == null ? -1 : daysUntil(a.dueDate) - daysUntil(b.dueDate);
+      return deadlineOrder || (a.priority === 0 ? 5 : a.priority) - (b.priority === 0 ? 5 : b.priority);
+    });
+    count = issues.length;
+    const lines = issues.map((item: LinearProjectIssue) => {
+      const days = item.dueDate ? daysUntil(item.dueDate) : null;
+      if (days !== null && days < 0) overdue++;
+      const deadline = days === null ? '마감 없음' : days < 0 ? `지남 ${-days}일` : `D-${days}`;
+      return `${deadline} · ${item.title} · ${item.state.name} · ${item.assignee?.name ?? '미배정'}\n${item.url}`;
+    });
+    debug.log('coo.admin', 'read', { count, overdue, reason: 'ok' });
+    const scope = issues.truncated ? '최대 250건 중 조회한 항목만 마감 순으로 표시 (이후 항목은 포함되지 않음)\n' : '';
+    const prose = lines.length ? `${scope}${lines.join('\n')}` : '남은 행정 0건';
+    const card = formatElanousCard({ kind: 'coo-admin', items: issues.map(item => ({
+      title: item.title, due: item.dueDate?.slice(0, 10) ?? null,
+      daysLeft: item.dueDate ? daysUntil(item.dueDate) : null,
+      state: item.state.name, owner: item.assignee?.name ?? '미배정', url: item.url,
+    })) });
+    return `${prose}\n${card}`;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('coo.admin', 'failed', { count, overdue, reason: 'linear-read-failed' });
+    return `못 읽었습니다(${reason})`;
+  }
+}

package/src/domains/core-tools.ts

@@ -15,7 +15,7 @@ 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 { runRecall, CONTEXT_NOW_SPEC, 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';
@@ -28,6 +28,9 @@ import { OPS_STATUS_SPEC, dispatchOpsStatus } from './ops-status-tool.js';
 import { SE_BUILD_SPEC, dispatchSeBuild } from './se-build-tool.js';
 import { LOGS_QUERY_SPEC, dispatchLogsQuery } from './logs-tool.js';
 import { MISSION_DECIDE_SPEC, dispatchMissionDecide } from '../autopilot/mission-decide-tool.js';
+import { COO_ADMIN_SPEC, dispatchCooAdmin } from './coo-admin-tool.js';
+import { RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, dispatchReleaseStatus, dispatchReleaseChange } from './release-tool.js';
+import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, dispatchOpsSeats, dispatchDecisionsPending } from './ops-facts-tool.js';
 
 /** memory_recall — 크로스서피스 기억(자기 발송 원장 회상). 도메인 무관(domain 필터는 옵션).
  *  finance-tools 에서 L2 로 이관(2026-07-08). */
@@ -111,6 +114,7 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onParti
   schedule_manage: dispatchScheduleManage,
   session_manage: (args) => dispatchSessionQuery(args), // 대화 세션 검색·열람·목록·삭제(내용/ID/텔레그램)
   memory_recall: dispatchMemoryRecall,
+  context_now: async (args) => (await import('../context-bus/context-now.js')).contextNow({ ...(typeof args.topic === 'string' ? { topic: args.topic } : {}) }),
   fact_check: dispatchFactCheck, // 팩트체크 캐스케이드(내부 발송원장→외부 X/레딧/웹)·도메인 무관 코어
   self_recall: dispatchSelfRecall, // self-awareness(elanous 구현 이력)·도메인 무관 코어
   autopilot_missions: dispatchAutopilotMissions, // 오토파일럿 계보 조회(AL3)·도메인 무관 코어
@@ -118,6 +122,8 @@ const CORE_TOOL_HANDLERS: Record<string, (args: Record<string, unknown>, onParti
   se_build: dispatchSeBuild, // SE 격리 빌드 관측(빌드 안 뭐 하나·로그 tail·worktree diff)·코어
   logs_query: dispatchLogsQuery, // 크로스서피스 디버그 로그 조회(logs.db·LF3)·READ-ONLY 코어
   mission_decide: dispatchMissionDecide, // 미션 결정 기록(re-ground·defer·boundary…)·3박자 주입·코어
+  coo_admin: (args) => dispatchCooAdmin(args),
+  release_status: async (args) => dispatchReleaseStatus(args),
 };
 
 /** Worker-side search entry: dispatch must not re-enter its own budget wrapper. */
@@ -136,7 +142,7 @@ const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
     },
   },
 };
-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 const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
@@ -153,11 +159,14 @@ export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
     names,
     dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
-      if (!h) return { error: `unknown core tool: ${name}` };
+      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending') return { error: `unknown core tool: ${name}` };
+      if (name === 'release_change') return dispatchReleaseChange(args, context);
+      if (name === 'ops_seats') return dispatchOpsSeats(args, context);
+      if (name === 'decisions_pending') return dispatchDecisionsPending(context);
       if (name === 'memory_recall' || name === 'self_recall') {
         return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
       }
-      return h(args, onPartial);
+      return h!(args, onPartial);
     },
   };
 }

package/src/domains/elanous-card.ts

@@ -0,0 +1,29 @@
+export interface ElanousCard {
+  kind: 'coo-admin' | 'release-schedule' | 'release-checklist';
+  items: Array<{ title: string; due: string | null; daysLeft: number | null; state: string; owner: string; url?: string }>;
+  meta?: Record<string, unknown>;
+}
+
+export function formatElanousCard(card: ElanousCard): string {
+  return `\`\`\`elanous-card\n${JSON.stringify(card)}\n\`\`\``;
+}
+
+/** Reads every valid card block in a tool response; ignores unrelated prose and malformed blocks. */
+export function parseElanousCard(text: string): ElanousCard[] {
+  const cards: ElanousCard[] = [];
+  for (const match of text.matchAll(/```elanous-card\r?\n([^\r\n]+)\r?\n```/g)) {
+    try {
+      const value: unknown = JSON.parse(match[1]!);
+      if (!value || typeof value !== 'object') continue;
+      const card = value as Partial<ElanousCard>;
+      if (!['coo-admin', 'release-schedule', 'release-checklist'].includes(card.kind ?? '') || !Array.isArray(card.items)) continue;
+      if (!card.items.every(item => item && typeof item.title === 'string' &&
+        (item.due === null || /^\d{4}-\d{2}-\d{2}$/.test(item.due)) &&
+        (item.daysLeft === null || typeof item.daysLeft === 'number') &&
+        typeof item.state === 'string' && typeof item.owner === 'string' &&
+        (item.url === undefined || typeof item.url === 'string'))) continue;
+      cards.push(card as ElanousCard);
+    } catch { /* Other fenced content is not a card. */ }
+  }
+  return cards;
+}

package/src/domains/ops-facts-tool.ts

@@ -0,0 +1,76 @@
+import type { LLMToolSpec } from '../llm.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
+import { debug } from '../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { buildSeatsBoard, todayKst, type SeatsSources } from '../nexus/api/ops-seats.js';
+import { liveSeatsSources } from '../nexus/api/ops-seats-sources.js';
+
+export const OPS_SEATS_SPEC: LLMToolSpec = {
+  name: 'ops_seats',
+  description: '오너 전용 읽기 — 지금 자리(OP·TC·MK·UX)별 진행(now), 오늘 착지(landed), 빨강(red), 미결 결정 수를 원장에서 확인한다. null은 못 읽은 원천이며 0이나 빈 목록이 아니다.',
+  parameters: { type: 'object', properties: { date: { type: 'string', description: '조회할 KST 날짜 YYYY-MM-DD. 생략하면 KST 오늘.' } }, required: [] },
+};
+
+export const DECISIONS_PENDING_SPEC: LLMToolSpec = {
+  name: 'decisions_pending',
+  description: '오너 전용 읽기 — 결정 원장의 열린 결정을 기한 순으로 조회한다. 결정 선택·기록은 하지 않는다.',
+  parameters: { type: 'object', properties: {}, required: [] },
+};
+
+export interface OpsFactsDeps {
+  seatsSources?: () => SeatsSources;
+  listDecisions?: (filters: { status: 'open' }) => DecisionEntry[];
+  today?: () => string;
+}
+
+function ownerVerified(context?: ToolRuntimeContext): boolean {
+  return context?.requestOrigin !== 'external-agent' && !!context?.sessionId && !!context?.verifiedOwner?.id.trim();
+}
+
+function logCall(tool: 'ops_seats' | 'decisions_pending', ok: boolean, nulls: number): void {
+  debug.log('ops.facts', 'call', { tool, ok, nulls });
+}
+
+/** Unreadable seat sources remain null; only rename the board's `blocked` field to `red` for this tool. */
+export async function dispatchOpsSeats(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('ops_seats', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  const date = args.date === undefined ? (deps.today ?? todayKst)() : args.date;
+  if (typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date) ||
+    !Number.isFinite(Date.parse(`${date}T00:00:00Z`)) || new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date) {
+    logCall('ops_seats', false, 0);
+    return { error: 'KST 날짜는 YYYY-MM-DD 여야 한다' };
+  }
+  try {
+    const board = await buildSeatsBoard(date, (deps.seatsSources ?? liveSeatsSources)());
+    const seats = board.seats.map(({ seat, role, now, landed, blocked, pendingDecisions }) =>
+      ({ seat, role, now, landed, red: blocked, pendingDecisions }));
+    const nulls = seats.reduce((n, row) => n + [row.now, row.landed, row.red, row.pendingDecisions].filter(v => v === null).length, 0);
+    logCall('ops_seats', true, nulls);
+    return { note: 'null = 못 읽음(없다가 아님); now는 오늘 기록이 없어도 null일 수 있다.', date: board.date, seats };
+  } catch {
+    logCall('ops_seats', false, 1);
+    return { error: '자리 현황을 읽지 못했다', seats: null };
+  }
+}
+
+/** Only the five requested fields leave the decision ledger. Undated entries follow dated entries. */
+export function dispatchDecisionsPending(context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('decisions_pending', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  try {
+    const entries = (deps.listDecisions ?? ((filters) => new DecisionLedger().list(filters)))({ status: 'open' });
+    const items = entries.filter(e => e.status === 'open')
+      .sort((a, b) => (a.dueAt ?? '\uffff').localeCompare(b.dueAt ?? '\uffff') || a.id.localeCompare(b.id))
+      .map(({ id, title, category, dueAt, raisedBy }) => ({ id, title, category, dueAt: dueAt ?? null, raisedBy: { track: raisedBy.track ?? null } }));
+    logCall('decisions_pending', true, items.reduce((n, item) => n + Number(item.dueAt === null) + Number(item.raisedBy.track === null), 0));
+    return { items };
+  } catch {
+    logCall('decisions_pending', false, 1);
+    return { error: '결정 원장을 읽지 못했다', items: null };
+  }
+}

package/src/domains/outbound-alert.ts

@@ -13,9 +13,9 @@ import { conatusEnv } from './conatus-env.js';
 import { spillLongContent } from '../storage/content-spill.js';
 import { openSurfaceEventsDb, recordEvent } from './surface-events.js';
 import { latestUserIntentTs } from '../user-intent/index.js';
-import { getUserConfig } from '../user-config.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChannelBotToken } from '../channel-bot-token.js';
-import { kindRouteTarget } from './telegram-kind-route.js';
+import { isOperationalKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } 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';
@@ -210,9 +210,14 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   ].join('\n');
   observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))]);
   let delivered = 0;
-  // origin 없는 것 = report 묶음(기존 동작·finance/크론 알림).
+  // origin 없는 매매 알림만 report 묶음. 그 외는 kind 별로 운영 봇 경계를 유지한다.
   const noOrigin = items.filter(i => !i.origin);
-  if (noOrigin.length && deliver(fmt(noOrigin), 'report')) delivered += noOrigin.length;
+  const tradingBatch = noOrigin.filter(i => !isOperationalKind(i.kind));
+  if (tradingBatch.length && deliver(fmt(tradingBatch), 'report')) delivered += tradingBatch.length;
+  for (const kind of new Set(noOrigin.filter(i => isOperationalKind(i.kind)).map(i => i.kind))) {
+    const batch = noOrigin.filter(i => i.kind === kind);
+    if (deliver(fmt(batch), kind)) delivered += batch.length;
+  }
   // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
   for (const it of items) {
@@ -402,20 +407,48 @@ function sendTelegramRaw(token: string, chatId: string | number, text: string, t
   return ok;
 }
 
-/** 텔레그램 직접 발송(TELEGRAM_BOT_TOKEN/CHAT_ID — env 우선, 없으면 CONATUS/.env). report 폴백. */
-function sendTelegramDirect(text: string, kind?: string): boolean {
-  // A purpose kind with a channel role (intake · ops-*) goes to that channel even when the daemon is down.
-  try {
-    const target = kindRouteTarget(getUserConfig(), kind);
-    if (target) return sendTelegramRaw(target.botToken, String(target.chatId), text);
-  } catch { /* fall through to the legacy direct path */ }
+/** 텔레그램 직접 발송. 운영 kind 는 메인 봇/홈 밖의 env 로 내려가지 않는다. */
+export function sendTelegramDirect(
+  text: string, kind?: string,
+  deps: { config?: UserConfig; sendRaw?: typeof sendTelegramRaw; legacyEnv?: typeof conatusEnv } = {},
+): boolean {
+  const sendRaw = deps.sendRaw ?? sendTelegramRaw;
+  let cfg: UserConfig | undefined;
+  try { cfg = deps.config ?? getUserConfig(); } catch { /* unavailable config: operational delivery still fails closed */ }
+  if (cfg) {
+    try {
+      const target = kindRouteTarget(cfg, kind);
+      if (target) return sendRaw(target.botToken, String(target.chatId), text);
+    } catch { /* unavailable channel routing: fall through */ }
+    // A declared table is authoritative: missing roles cannot escape to an env bot.
+    if (cfg.telegram.channels?.length) {
+      logKindRouteFallback(kind, 'none', false);
+      return false;
+    }
+  }
+  if (isOperationalKind(kind)) {
+    let home: ReturnType<typeof mainHomeTarget> = null;
+    let mainToken = '';
+    try {
+      if (cfg) {
+        mainToken = resolveChannelBotToken('telegram', cfg).token;
+        home = mainHomeTarget(cfg);
+      }
+    } catch { /* unavailable main bot */ }
+    const rcToken = cfg?.telegram.reportChannel?.botToken;
+    logKindRouteFallback(kind, home ? 'main-home' : 'none', !!mainToken && !!cfg?.telegram.reportChannel && (!rcToken || rcToken === mainToken));
+    if (home) return sendRaw(home.botToken, String(home.chatId), text);
+    console.error('[outbound] 운영 kind 메인 봇/홈 미설정 — 콘솔 출력\n' + text);
+    return false;
+  }
   let tok = process.env.TELEGRAM_BOT_TOKEN || '';
   let chat = process.env.TELEGRAM_CHAT_ID || '';
   if (!tok || !chat) {
-    const env = conatusEnv();
+    const env = (deps.legacyEnv ?? conatusEnv)();
     tok = tok || env.TELEGRAM_BOT_TOKEN || '';
     chat = chat || env.TELEGRAM_CHAT_ID || '';
   }
+  logKindRouteFallback(kind, tok && chat ? 'conatus-env' : 'none', false);
   if (!tok || !chat) { console.error('[outbound] 토큰/chat 미설정 — 콘솔 출력\n' + text); return false; }
-  return sendTelegramRaw(tok, chat, text);
+  return sendRaw(tok, chat, text);
 }

package/src/domains/release-tool.ts

@@ -0,0 +1,168 @@
+import type { LLMToolSpec } from '../llm.js';
+import type { ToolRuntimeContext } from '../tool-runtime/types.js';
+import { debug } from '../debug/log.js';
+import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hitl/confirm.js';
+import { devVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
+import { add, move, validateVersion } from '../release-loop/feature-store.js';
+import { formatKst, getSchedule, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
+import { formatElanousCard, type ElanousCard } from './elanous-card.js';
+
+export const RELEASE_STATUS_SPEC: LLMToolSpec = {
+  name: 'release_status',
+  description: '판 어디까지 · 컷 언제 · 릴리스 상황 · 판올림 · 체크리스트 · 남은 칸을 읽는다. 판 일정, 빨강 칸, 담당별 노랑, 최근 발행 런을 조회하는 읽기 전용 도구. 행정 업무는 coo_admin.',
+  parameters: { type: 'object', properties: { version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' } }, required: [] },
+};
+
+export const RELEASE_CHANGE_SPEC: LLMToolSpec = {
+  name: 'release_change',
+  description: '오너의 판올림 변경 요청 — 체크리스트 칸 추가, 칸을 다른 판으로 이동, 판 컷·착지 마감 수정. 실행 전에 사람에게 한 번 확인받는다. 읽기 요청에는 release_status 사용.',
+  parameters: { type: 'object', properties: {
+    action: { type: 'string', enum: ['add-item', 'move-item', 'set-schedule'] },
+    version: { type: 'string', description: 'add-item 또는 set-schedule 대상 판' },
+    id: { type: 'string', description: '칸 id (add-item 또는 move-item)' },
+    title: { type: 'string', description: '추가할 칸 제목' },
+    owner: { type: 'string', description: '추가할 칸 담당(선택)' },
+    from: { type: 'string', description: '이동 전 판' },
+    to: { type: 'string', description: '이동 후 판' },
+    cutAt: { type: 'string', description: 'ISO 오프셋 포함 컷 시각(선택)' },
+    landBy: { type: 'string', description: 'ISO 오프셋 포함 착지 마감(선택)' },
+  }, required: ['action'] },
+};
+
+export interface ReleaseToolDeps {
+  now?: Date;
+  devVersion?: () => string;
+  checklist?: (version: string) => Checklist;
+  schedule?: (version: string) => ReleaseSchedule | null;
+  latestRun?: (graphId: string) => GraphRunState | null;
+  confirm?: (options: ConfirmOpts) => Promise<ConfirmResult>;
+  add?: typeof add;
+  move?: typeof move;
+  setSchedule?: typeof setSchedule;
+}
+
+function nextVersion(version: string): string {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return `${major}.${minor}.${patch! + 1}`;
+}
+
+function kstDate(iso: string): string {
+  return new Date(Date.parse(iso) + 9 * 60 * 60_000).toISOString().slice(0, 10);
+}
+
+function daysLeft(iso: string, now: Date): number {
+  const due = Date.parse(`${kstDate(iso)}T00:00:00Z`);
+  const today = Date.parse(`${kstDate(now.toISOString())}T00:00:00Z`);
+  return (due - today) / 86_400_000;
+}
+
+function dDay(days: number): string {
+  return days < 0 ? `D+${-days}` : days === 0 ? 'D-day' : `D-${days}`;
+}
+
+export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+  const requested = args.version;
+  if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
+  const version = requested ? null : (deps.devVersion?.() ?? devVersion());
+  const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
+  const now = deps.now ?? new Date();
+  const run = (deps.latestRun ?? latestGraphRun)('release-loop');
+  const latest = run ? { status: run.status, lastNode: run.path.at(-1) ?? null, startedAt: run.startedAt ?? null } : null;
+  const entries = versions.map(v => {
+    validateVersion(v);
+    const schedule = (deps.schedule ?? getSchedule)(v);
+    const data = (deps.checklist ?? listChecklist)(v);
+    const summary = summarizeChecklist(data);
+    const red = data.items.filter(item => item.status === 'red').map(({ id, title, owner }) => ({ id, title, owner: owner ?? '미배정' }));
+    const yellowByOwner: Record<string, number> = {};
+    for (const item of data.items.filter(item => item.status === 'yellow')) {
+      const owner = item.owner ?? '미배정';
+      yellowByOwner[owner] = (yellowByOwner[owner] ?? 0) + 1;
+    }
+    const cutDaysLeft = schedule ? daysLeft(schedule.cutAt, now) : null;
+    const landDaysLeft = schedule?.landBy ? daysLeft(schedule.landBy, now) : null;
+    const cutHoursLeft = schedule ? Math.ceil((Date.parse(schedule.cutAt) - now.getTime()) / 3_600_000) : null;
+    const landHoursLeft = schedule?.landBy ? Math.ceil((Date.parse(schedule.landBy) - now.getTime()) / 3_600_000) : null;
+    return { version: v, schedule: schedule ? { cutAt: schedule.cutAt, landBy: schedule.landBy, cutDaysLeft, landDaysLeft, cutHoursLeft, landHoursLeft } : null,
+      counts: { green: summary.green, yellow: summary.yellow, red: summary.red, done: summary.done }, red, yellowByOwner };
+  });
+  const lines = entries.map(entry => {
+    const schedule = entry.schedule;
+    return `${entry.version} · 컷 ${schedule ? formatKst(schedule.cutAt) : '미정'}${schedule?.landBy ? ` · 착지 마감 ${formatKst(schedule.landBy)}` : ' · 착지 마감 미정'}${schedule ? ` · 컷 ${dDay(schedule.cutDaysLeft!)} (${schedule.cutHoursLeft}시간)${schedule.landDaysLeft !== null ? ` · 착지 ${dDay(schedule.landDaysLeft)} (${schedule.landHoursLeft}시간)` : ''}` : ''}\n` +
+      `초록 ${entry.counts.green} · 노랑 ${entry.counts.yellow} · 빨강 ${entry.counts.red} · 끝 ${entry.counts.done}\n` +
+      `빨강 칸: ${entry.red.length ? entry.red.map(item => `${item.id} ${item.title} (${item.owner})`).join(', ') : '없음'}\n` +
+      `담당별 노랑: ${Object.keys(entry.yellowByOwner).length ? Object.entries(entry.yellowByOwner).map(([owner, count]) => `${owner} ${count}`).join(', ') : '없음'}`;
+  });
+  lines.push(latest ? `최근 발행 런: ${latest.status} · 끝 노드 ${latest.lastNode ?? '없음'} · 시작 ${latest.startedAt ?? '미상'}` : '최근 발행 런: 없음');
+  const cards: ElanousCard[] = [
+    { kind: 'release-schedule', items: entries.map(entry => ({ title: `${entry.version} 컷`, due: entry.schedule ? kstDate(entry.schedule.cutAt) : null, daysLeft: entry.schedule?.cutDaysLeft ?? null, state: entry.schedule ? 'scheduled' : 'undecided', owner: 'release' })), meta: { versions: entries.map(entry => entry.version) } },
+    { kind: 'release-checklist', items: entries.flatMap(entry => entry.red.map(item => ({ title: `${item.id} ${item.title}`, due: null, daysLeft: null, state: 'red', owner: item.owner }))), meta: { counts: entries.map(entry => ({ version: entry.version, ...entry.counts })) } },
+  ];
+  const structured = { releases: entries, latestRun: latest };
+  debug.log('release.tool', 'status', { action: 'status', version: versions.join(',') });
+  return { text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}`, structured };
+}
+
+function requiredString(args: Record<string, unknown>, key: string): string {
+  const value = args[key];
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${key} 값이 필요합니다`);
+  return value.trim();
+}
+
+/** Never accepts a user-supplied owner claim: only a human, server-assigned owner context can authorize a mutation. */
+export async function dispatchReleaseChange(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: ReleaseToolDeps = {}): Promise<string> {
+  const action = typeof args.action === 'string' ? args.action : '';
+  const version = typeof args.version === 'string' ? args.version : typeof args.from === 'string' ? args.from : '';
+  const ownerId = context?.verifiedOwner?.id;
+  if (context?.requestOrigin === 'external-agent' || !context?.sessionId || !ownerId?.trim()) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return '서버에서 검증한 오너의 사람 채팅 문맥에서만 판올림을 바꿀 수 있습니다.';
+  }
+  const channels = context.confirmChannels;
+  if (!channels?.length) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return '원래 채팅의 확인 채널이 없어 판올림을 바꾸지 않았습니다.';
+  }
+  let prompt: string;
+  let apply: () => void;
+  if (action === 'add-item') {
+    const v = requiredString(args, 'version');
+    const id = requiredString(args, 'id');
+    const title = requiredString(args, 'title');
+    validateVersion(v);
+    const owner = args.owner === undefined ? undefined : requiredString(args, 'owner');
+    prompt = `${v} 에 칸 ${id} «${title}» 추가 — 진행할까요?`;
+    apply = () => { (deps.add ?? add)(v, { id, title, status: 'yellow', ...(owner ? { owner } : {}), updatedAt: new Date().toISOString(), updatedBy: ownerId }); };
+  } else if (action === 'move-item') {
+    const id = requiredString(args, 'id');
+    const from = requiredString(args, 'from');
+    const to = requiredString(args, 'to');
+    validateVersion(from); validateVersion(to);
+    if (from === to) throw new Error('같은 판으로 옮길 수 없습니다');
+    prompt = `${id} 칸을 ${from} 에서 ${to} 로 이동 — 진행할까요?`;
+    apply = () => { (deps.move ?? move)(id, from, to, ownerId); };
+  } else if (action === 'set-schedule') {
+    const v = requiredString(args, 'version');
+    validateVersion(v);
+    const cutAt = args.cutAt === undefined ? undefined : requiredString(args, 'cutAt');
+    const landBy = args.landBy === undefined ? undefined : requiredString(args, 'landBy');
+    if (!cutAt && !landBy) throw new Error('cutAt 또는 landBy 가 필요합니다');
+    // Validate offsets before asking for approval, not after.
+    for (const iso of [cutAt, landBy].filter((value): value is string => !!value)) {
+      if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d{1,3})?)?(?:Z|[+-]\d\d:\d\d)$/.test(iso) || !Number.isFinite(Date.parse(iso))) throw new Error(`잘못된 ISO 시각: ${iso}`);
+    }
+    prompt = `${v} 판 일정 ${cutAt ? `컷 ${formatKst(cutAt)}` : ''}${landBy ? ` 착지 마감 ${formatKst(landBy)}` : ''} 변경 — 진행할까요?`;
+    apply = () => { (deps.setSchedule ?? setSchedule)(v, { ...(cutAt ? { cutAt } : {}), ...(landBy ? { landBy } : {}) }, ownerId); };
+  } else throw new Error('action 은 add-item, move-item, set-schedule 중 하나여야 합니다');
+  debug.log('release.tool', 'change-requested', { action, version });
+  const result = await (deps.confirm ?? requestConfirmation)({ prompt, onTimeout: () => false, failOpen: false,
+    channels });
+  if (!result.answer || !channels.some(channel => channel.name === result.channel)) {
+    debug.log('release.tool', 'change-refused', { action, version });
+    return `${prompt} — 승인되지 않아 변경하지 않았습니다.`;
+  }
+  apply();
+  debug.log('release.tool', 'change-confirmed', { action, version });
+  return `${prompt} — 변경했습니다.`;
+}