elanous 0.2.8 → 0.2.10

package/src/decisions/web-push-decision-cards.ts

@@ -0,0 +1,50 @@
+import { debug } from '../debug/log.js';
+import { listSubscriptions } from '../web-push/subscriptions.js';
+import { sendPushToAll } from '../web-push/sender.js';
+import { type CardTransport, type CardView } from './decision-cards.js';
+import { DecisionLedger } from './decision-ledger.js';
+
+const ID_IN_CARD = /^🗳 결정 요청 (D-\d{8}-\d+)(?: ·|\n)/;
+const ID_IN_REMINDER = /^⏰ 기한 2시간 전 — (D-\d{8}-\d+) /;
+const TITLE_LIMIT = 60;
+
+export function webPushDecisionTransport(
+  ledger: DecisionLedger,
+  deps: { subscriptions?: typeof listSubscriptions; push?: typeof sendPushToAll } = {},
+): CardTransport {
+  const subscriptions = deps.subscriptions ?? listSubscriptions;
+  const push = deps.push ?? sendPushToAll;
+  const title = (prefix: string, name: string) => prefix + Array.from(name).slice(0, TITLE_LIMIT - Array.from(prefix).length).join('');
+  const url = (id: string) => `/approvals?decision=${encodeURIComponent(id)}`;
+  const tag = (id: string) => `decision-${id}`;
+  return {
+    platform: 'webpush',
+    ownerChats: async () => subscriptions().length ? ['webpush'] : [],
+    send: async (_chat, view: CardView) => {
+      const id = ID_IN_CARD.exec(view.text)?.[1];
+      if (!id || !subscriptions().length) return null;
+      const entry = ledger.show(id);
+      if (entry.status !== 'open') return null;
+      const recommendation = 'skipped' in entry.recommendation ? '추천안 없음' : `추천안: ${entry.recommendation.option.toUpperCase()}`;
+      const body = `${recommendation}${entry.dueAt ? ` · 기한: ${new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: 'numeric', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false }).format(new Date(entry.dueAt))}` : ''}`;
+      const result = await push({ title: title('대표 결정 · ', entry.title), body, url: url(id), tag: tag(id) });
+      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+      return result.delivered ? { chat: 'webpush', message: id } : null;
+    },
+    edit: async (ref, _view) => {
+      const id = ref.message;
+      const entry = ledger.show(id);
+      if (entry.status === 'open' || !subscriptions().length) return;
+      const result = await push({ title: title('결정됨 · ', entry.title), url: url(id), tag: tag(id), data: { silent: true } });
+      debug.log('decisions.webpush', 'card-closed', { id, delivered: result.delivered });
+    },
+    notify: async (_chat, text) => {
+      const id = ID_IN_REMINDER.exec(text)?.[1];
+      if (!id || !subscriptions().length) return;
+      const entry = ledger.show(id);
+      if (entry.status !== 'open') return;
+      const result = await push({ title: title('기한 알림 · ', entry.title), body: `기한 2시간 전 · ${id}`, url: url(id), tag: tag(id) });
+      debug.log('decisions.webpush', 'card-sent', { id, delivered: result.delivered });
+    },
+  };
+}

package/src/directive/interpretation-card.ts

@@ -0,0 +1,36 @@
+import { listChecklist, type ChecklistItem } from '../release-loop/checklist.js';
+
+export interface InterpretationCard {
+  what: string;
+  cell: string | null;
+  unknowns: string[];
+}
+
+export type CellCandidate = Pick<ChecklistItem, 'id' | 'title'>;
+
+/** The same SQLite-backed cells exposed by `elanous release checklist list --version <v>`. */
+export function readCellCandidates(version: string): CellCandidate[] {
+  return listChecklist(version).items.map(({ id, title }) => ({ id, title }));
+}
+
+/** Interpret a single directive without querying state or inventing a release cell. */
+export function interpretDirective(line: string, candidates: readonly CellCandidate[]): InterpretationCard {
+  if (/\r|\n/.test(line)) throw new Error('지시는 한 줄이어야 한다');
+  const what = line.trim();
+  if (!what) throw new Error('빈 지시는 해석할 수 없다');
+
+  const matches = candidates.filter(({ id, title }) =>
+    (id && new RegExp(`(^|[^\\p{L}\\p{N}])${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=$|[^\\p{L}\\p{N}]|[을를은는이가에의와과])`, 'u').test(what)) ||
+    (title && what.includes(title)));
+
+  if (matches.length === 1) return { what, cell: matches[0]!.id, unknowns: [] };
+  return {
+    what,
+    cell: null,
+    unknowns: [matches.length ? `칸 후보가 여럿이다: ${matches.map(({ id }) => id).join(', ')}` : '연결할 칸을 확인해야 한다'],
+  };
+}
+
+export function renderInterpretationCard(card: InterpretationCard): string {
+  return `무엇: ${card.what}\n칸: ${card.cell ?? '확인 필요'}\n미확인: ${card.unknowns.join(', ') || '없음'}`;
+}

package/src/discord.ts

@@ -837,13 +837,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

@@ -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). */
@@ -118,6 +121,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 +141,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, 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 +158,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 없는 finance 는 기존 report 묶음. 운영 보류분은 별도로 묶어 운영 봇 경계를 유지한다.
   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,43 @@ 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 */ }
+  }
+  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} — 변경했습니다.`;
+}

package/src/domains/telegram-kind-route.ts

@@ -1,12 +1,30 @@
 // 발송 목적(kind) → 텔레그램 채널 역할 · 대상. 가벼운 모듈(telegram.ts 를 import 하지 않는다 — outbound-alert 순환 방지).
-// 표에 없는 kind 는 undefined → 부르는 쪽이 옛 reportChannel 로 간다(투자 알림 등 기존 동작 그대로).
+// 표에 없는 kind 는 undefined → 부르는 쪽이 폴백을 판정한다(투자 알림은 옛 reportChannel 유지).
 import type { UserConfig } from '../user-config.js';
+import { resolveChannelBotToken } from '../channel-bot-token.js';
+import { debug } from '../debug/log.js';
 import { channelForRole, resolveTelegramChannels } from './telegram-channels.js';
 
 export const DEFAULT_KIND_ROLES: Readonly<Record<string, string>> = {
   intake: 'system', 'ops-report': 'system', 'ops-alert': 'system', 'ops-health': 'system',
+  regression: 'system', 'agent-mission': 'system',
 };
 
+/** No channel mapping for an operational kind may cross into a different bot. */
+export function isOperationalKind(kind?: string): boolean {
+  return kind?.startsWith('ops-') ?? false;
+}
+
+export function mainHomeTarget(cfg: UserConfig): { botToken: string; chatId: number } | null {
+  const botToken = resolveChannelBotToken('telegram', cfg).token;
+  const chatId = cfg.telegram.homeChannel ?? cfg.telegram.allowedUsers[0];
+  return botToken && chatId != null && Number.isFinite(chatId) ? { botToken, chatId } : null;
+}
+
+export function logKindRouteFallback(kind: string | undefined, to: 'report-channel' | 'main-home' | 'conatus-env' | 'none', sameBot: boolean): void {
+  try { debug.log('telegram.kind-route', 'fallback', { kind, to, sameBot }); } catch { /* logging must not prevent delivery */ }
+}
+
 export function roleForKind(cfg: UserConfig, kind?: string): string | undefined {
   if (!kind) return undefined;
   return cfg.telegram.kindRoles?.[kind] ?? DEFAULT_KIND_ROLES[kind];