elanous 0.2.10 → 0.2.11

package/src/telegram-card-followup.ts

@@ -1,13 +1,13 @@
-import { chmodSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { chmodSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { debug } from './debug/log.js';
 import { effectiveInstanceRoot } from './instance/resolve.js';
-import { lastJsonObject, runGraph, type GraphRunState } from './graph-runner/runner.js';
+import { runGraph } from './graph-runner/runner.js';
+import { cardShape, detectCard, runCardFollowup, NotACardError, type CardDetectDecision } from './card-followup/core.js';
 import type { TgIncoming } from './telegram.js';
 
-const GRAPH = resolve(import.meta.dir, '../plugins/card-followup/graphs/card-followup.yaml');
 // Latin keywords are whole words only — «postcard» or «cardinal» is not a card request (review round 3).
 const KEYWORD = /명함|전략|메일\s*초안|초안|팔로업|\bcard\b|\bCRM\b/i;
 /** Untagged albums start one graph run, not one per photo (chatId:mediaGroupId → first seen at). */
@@ -22,30 +22,7 @@ function firstOfAlbum(chatId: number, mediaGroupId: string | undefined, now: num
   return true;
 }
 
-// Captionless photos start a run only when they look like a business card (OP 10-02 18:54 · cheap signals first, ambiguous → nothing).
-export type CardDetectDecision = 'card' | 'skip' | 'ambiguous';
-export function cardShape(width?: number, height?: number): { decision: 'skip' | 'pass'; signal: string } {
-  if (!width || !height) return { decision: 'pass', signal: 'ratio:unknown' };
-  const ratio = Math.max(width, height) / Math.min(width, height);
-  if (ratio < 1.15) return { decision: 'skip', signal: 'ratio:square' };
-  if (ratio > 2.0) return { decision: 'skip', signal: 'ratio:screenshot' };
-  return { decision: 'pass', signal: `ratio:${ratio.toFixed(2)}` };
-}
-const EMAIL = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
-const PHONE = /(?:\+?\d{1,3}[\s.-]?)?\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{4}/;
-const WEB = /\b(?:https?:\/\/|www\.)\S+|\b[a-z0-9-]+\.(?:com|co\.kr|kr|io|ai|net|org)\b/i;
-const TITLE = /대표|이사|팀장|부장|과장|실장|매니저|주식회사|\(주\)|\b(?:CEO|CTO|COO|CFO|Director|Manager|Founder|Inc|Ltd|Corp)\b/i;
-/** Card text is short and carries contact patterns; long text is a document. Returns signal names only, never the text. */
-export function cardText(ocr: string | null): { decision: CardDetectDecision; signal: string } {
-  if (ocr === null) return { decision: 'ambiguous', signal: 'ocr:unavailable' };
-  const chars = ocr.replace(/\s+/g, '').length;
-  if (chars < 15) return { decision: 'ambiguous', signal: `ocr:chars<15` };
-  if (chars > 700) return { decision: 'skip', signal: 'ocr:document' };
-  const hits = ([['email', EMAIL], ['phone', PHONE], ['web', WEB], ['title', TITLE]] as const).filter(([, re]) => re.test(ocr)).map(([name]) => name);
-  const signal = `ocr:${hits.join(',') || 'none'}`;
-  if (hits.length >= 2) return { decision: 'card', signal };
-  return { decision: hits.length === 0 ? 'skip' : 'ambiguous', signal };
-}
+export { cardShape, cardText } from './card-followup/core.js';
 const OCR_SCRIPT = resolve(import.meta.dir, '../scripts/ocr-text-regions.swift');
 /** Local macOS Vision OCR (no network · no new dependency); null where it cannot run. */
 export function localOcrText(path: string, timeoutMs = 30_000): Promise<string | null> {
@@ -78,36 +55,6 @@ export interface CardPhotoDeps {
   ocrText?: (path: string) => Promise<string | null>;
 }
 
-const obj = (value: unknown): Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
-const text = (value: unknown): string => typeof value === 'string' ? value.trim() : '';
-const line = (value: unknown): string => (typeof value === 'number' && Number.isFinite(value) ? String(value) : text(value)).replace(/[\r\n]+/g, ' ') || '—';
-
-function isNotACard(state: GraphRunState): boolean {
-  if (state.status !== 'failed') return false;
-  const read = state.nodes.find((node) => node.nodeId === 'read-card');
-  if (!read || !read.ok) return false;
-  const output = lastJsonObject(read.output);
-  if (output?.outcome === 'ok' && output.card && typeof output.card === 'object') {
-    const card = obj(output.card);
-    return !['name', 'company', 'title', 'email', 'phone', 'url', 'linkedin'].some((field) => text(card[field]));
-  }
-  return output?.outcome === 'fail' && typeof output.reason === 'string'
-    && /\bnot a (?:business )?card\b|명함이?\s*아님|명함이?\s*아닙니다/i.test(output.reason);
-}
-
-function validateReport(report: Record<string, unknown>): void {
-  const card = obj(report.card), fit = obj(report.fit), approach = obj(report.approach);
-  const next = obj(report.nextAction), draft = obj(report.draft);
-  const score = fit.score;
-  if (report.sent !== false || !text(card.name) || !text(card.company)
-    || !(score === null || (typeof score === 'number' && Number.isFinite(score)))
-    || !text(fit.label) || !text(approach.problem) || !text(approach.proposal)
-    || !text(approach.channel) || !text(next.what) || !text(next.due)
-    || !text(draft.subject) || !text(draft.body)) {
-    throw new Error('incomplete or sent card report');
-  }
-}
-
 function pick(caption: string): Picked {
   if (/\bCRM\b/i.test(caption)) return 'crm';
   if (/메일\s*초안|초안/i.test(caption)) return 'draft';
@@ -149,7 +96,7 @@ export async function maybeHandleCardPhoto(ctx: TgIncoming, deps: CardPhotoDeps)
       const { localPath } = await deps.downloadFile(photo.fileId, dir);
       chmodSync(localPath, 0o600);
       if (!caption) {
-        const verdict = cardText(await (deps.ocrText ?? localOcrText)(localPath));
+        const verdict = detectCard({ width: photo.width, height: photo.height, ocrText: await (deps.ocrText ?? localOcrText)(localPath) });
         detect(verdict.decision, verdict.signal);
         if (verdict.decision !== 'card') { rmSync(dir, { recursive: true, force: true }); return null; }
       }
@@ -166,38 +113,22 @@ export async function maybeHandleCardPhoto(ctx: TgIncoming, deps: CardPhotoDeps)
           try { localPath = await prepare(); } catch { log('failed'); return; }
           if (!localPath) return;
         }
-        const state = await (deps.runGraph ?? runGraph)(GRAPH, { runId, deps: { root }, input: {
-          image: localPath!, outDir: dir, ...(caption ? { context: caption } : {}),
-        } });
-        if (!deps.runGraph) {
-          const statePath = join(base, `${runId}.json`);
-          chmodSync(statePath, 0o600);
-          const contexts = `${statePath}.contexts`;
-          try {
-            chmodSync(contexts, 0o700);
-            for (const file of readdirSync(contexts)) chmodSync(join(contexts, file), 0o600);
-          } catch (error) {
-            if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-          }
-        }
-        if (isNotACard(state)) {
-          log('not-a-card');
-          return;
+        let result;
+        try {
+          result = await runCardFollowup({ imagePath: localPath!, ocrText: null,
+            runGraph: deps.runGraph ?? runGraph, rootDir: root, outDir: dir, runId,
+            ...(caption ? { context: caption } : {}),
+          });
+        } catch (error) {
+          if (error instanceof NotACardError) { log('not-a-card'); return; }
+          throw error;
         }
-        if (state.status !== 'done') throw new Error('graph did not finish');
-        const report = obj(JSON.parse(readFileSync(join(dir, 'followup.json'), 'utf8')));
-        validateReport(report);
-        const card = obj(report.card), fit = obj(report.fit), approach = obj(report.approach);
-        const next = obj(report.nextAction), draft = obj(report.draft);
-        const summary = `① 요약\n${line(card.name)} · ${line(card.company)} · ${line(card.title)}\n타겟 판정: ${line(fit.score)} · ${line(fit.label)}`;
-        const strategy = `② 전략\n${[approach.problem, approach.proposal, approach.channel].map(line).join('\n')}\n다음 행동: ${line(next.what)} · ${line(next.due)}`;
-        const mail = `③ 팔로업 초안 (보내지 않았습니다)\n제목: ${line(draft.subject)}\n${text(draft.body)}`;
-        const markdown = readFileSync(join(dir, 'followup.md'));
+        const markdown = readFileSync(result.followupPath!);
         const crmLine = picked === 'crm'
           ? /^## ② CRM 한 줄\r?\n파일: [^\r\n]*\r?\n([^\r\n]+)/m.exec(markdown.toString('utf8'))?.[1]
           : undefined;
         if (picked === 'crm' && !crmLine) throw new Error('CRM row missing from report');
-        const messages = picked === 'strategy' ? [strategy] : picked === 'draft' ? [mail] : picked === 'crm' ? [`CRM 한 줄\n${crmLine}`] : [summary, strategy, mail];
+        const messages = picked === 'strategy' ? [result.replies[1]] : picked === 'draft' ? [result.replies[2]] : picked === 'crm' ? [`CRM 한 줄\n${crmLine}`] : result.replies;
         for (const message of messages) await deps.sendMessage(ctx.chatId, message, reply);
         const sent = await deps.sendDocument(ctx.chatId, markdown, 'followup.md', { ...reply, mimeType: 'text/markdown' });
         if (sent === undefined) throw new Error('document delivery failed');
@@ -207,17 +138,6 @@ export async function maybeHandleCardPhoto(ctx: TgIncoming, deps: CardPhotoDeps)
         try {
           await deps.sendMessage(ctx.chatId, '명함 정리에 실패했습니다. 다시 시도해 주세요.', reply);
         } catch { /* Telegram delivery itself failed; the failure is already observed. */ }
-      } finally {
-        if (!deps.runGraph) {
-          // The runner may throw before returning its state; seal any partial state and contexts too.
-          const statePath = join(base, `${runId}.json`);
-          try { chmodSync(statePath, 0o600); } catch { /* no state yet */ }
-          const contexts = `${statePath}.contexts`;
-          try {
-            chmodSync(contexts, 0o700);
-            for (const file of readdirSync(contexts)) chmodSync(join(contexts, file), 0o600);
-          } catch { /* no contexts yet */ }
-        }
       }
     })();
   } catch {

package/src/telegram-commands.ts

@@ -44,6 +44,9 @@ import { readDaemonSessionHistory } from './telegram/daemon-history-reader.js';
 import { renderTelegramReplayPreviewHtml } from './telegram/replay-preview.js';
 import { classifyIntake } from './ad-pipeline/intake.js';
 import { createAdPipelineDeps, runAdPipeline } from './ad-pipeline/run.js';
+import { projectCommand } from './telegram-project-command.js';
+import { telegramNowSlash } from './context-bus/context-now-surfaces.js';
+import type { ContextNowDeps } from './context-bus/context-now.js';
 
 /** How many prior user/assistant turns to pass into `executeSkill` as
  *  the `## Recent conversation` block. Mirrors the dashboard default
@@ -291,7 +294,7 @@ function dropChatSessionReply(ctx: TgIncoming): string {
 /** Build the default command set for a Telegram bot wired via
  *  botFromConfig. Returns the array rather than mutating globals so
  *  tests can construct a variant set with stubbed handlers. */
-export function defaultTelegramCommands(): TgSlashCommand[] {
+export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashCommand[] {
   return [
     {
       name: 'help',
@@ -304,6 +307,11 @@ export function defaultTelegramCommands(): TgSlashCommand[] {
         return lines.join('\n');
       },
     },
+    {
+      name: 'now',
+      description: 'Show current release, decisions, seats and context: /now [topic]',
+      handler: async (args) => telegramNowSlash(args, nowDeps),
+    },
     {
       name: 'status',
       description: 'Show bot identity, current session, provider + model',
@@ -581,6 +589,7 @@ export function defaultTelegramCommands(): TgSlashCommand[] {
         return lines.join('\n');
       },
     },
+    projectCommand(),
     {
       name: 'fork',
       description: 'Fork the current chat session (or /fork <prefix>) and continue HERE on the fork · time-travel: /fork before:N',

package/src/telegram-project-command.ts

@@ -0,0 +1,71 @@
+import { debug } from './debug/log.js';
+import { getProject, listProjects, type Project } from './project/project-store.js';
+import { findSessionByTelegramChat, updateSessionMeta } from './session/index.js';
+import type { TgSlashCommand } from './telegram-commands.js';
+
+export interface TelegramProjectCommandDeps {
+  list: () => Project[];
+  find: (id: string) => Project | null;
+  update: typeof updateSessionMeta;
+  findSession: typeof findSessionByTelegramChat;
+}
+
+export function projectCommand(deps: TelegramProjectCommandDeps = {
+  list: listProjects,
+  find: getProject,
+  update: updateSessionMeta,
+  findSession: findSessionByTelegramChat,
+}): TgSlashCommand {
+  return {
+    name: 'project',
+    description: '이 대화의 프로젝트 보기·옮기기',
+    handler: async (args, ctx) => {
+      const session = deps.findSession(ctx.chatId, ctx.threadId, ctx.botId);
+      if (!session) {
+        debug.log('telegram.project', 'rejected', { projects: [], reason: 'no-session' });
+        return '아직 이 채팅에 대화가 없습니다 — 한 마디 보낸 뒤 다시';
+      }
+
+      if (args.length === 0) {
+        const current = session.projectId ? deps.find(session.projectId) : null;
+        const projects = deps.list().sort((a, b) => a.name.localeCompare(b.name)).slice(0, 20);
+        debug.log('telegram.project', 'listed', { projects: projects.map(p => ({ id: p.id, name: p.name })) });
+        return [
+          `지금 대화의 프로젝트: ${current?.name ?? '받은 대화(프로젝트 없음)'}`,
+          '',
+          '프로젝트 목록:',
+          ...projects.map(p => `• ${p.name}`),
+          '',
+          '옮기려면 /project <이름>',
+        ].join('\n');
+      }
+
+      const name = args.join(' ').trim();
+      if (name === '-') {
+        deps.update(session.id, m => { delete m.projectId; });
+        debug.log('telegram.project', 'cleared', { projects: [] });
+        return '받은 대화로 옮겼습니다';
+      }
+
+      const projects = deps.list();
+      const normalized = name.toLocaleLowerCase();
+      const exact = projects.filter(p => p.name.toLocaleLowerCase() === normalized);
+      const matches = exact.length ? exact : projects.filter(p => p.name.toLocaleLowerCase().startsWith(normalized));
+      if (matches.length === 0) {
+        debug.log('telegram.project', 'rejected', { projects: [], reason: 'not-found' });
+        return '그 이름의 프로젝트가 없습니다 — /project 로 목록 보기';
+      }
+      if (matches.length > 1) {
+        debug.log('telegram.project', 'rejected', {
+          projects: matches.map(p => ({ id: p.id, name: p.name })), reason: 'ambiguous',
+        });
+        return `여러 프로젝트가 맞습니다 — 이름을 골라 주세요:\n${matches.map(p => `• ${p.name}`).join('\n')}`;
+      }
+
+      const project = matches[0]!;
+      deps.update(session.id, m => { m.projectId = project.id; });
+      debug.log('telegram.project', 'moved', { projects: [{ id: project.id, name: project.name }] });
+      return `이 대화를 ${project.name} 프로젝트로 옮겼습니다`;
+    },
+  };
+}

package/src/telegram-report.ts

@@ -11,7 +11,7 @@
 // the report channel while interactive Q&A stays on the main bot.
 
 import { TelegramBot } from './telegram.js';
-import { isOperationalKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './domains/telegram-kind-route.js';
+import { isTradingKind, kindRouteTarget, logKindRouteFallback, mainHomeTarget } from './domains/telegram-kind-route.js';
 export { DEFAULT_KIND_ROLES, roleForKind } from './domains/telegram-kind-route.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 import type { UserConfig } from './user-config.js';
@@ -51,22 +51,27 @@ export interface ReportTarget {
   chatId: number;
 }
 
-/** Explicit role channels win. Without a role channel, operational kinds use the main bot's
- *  home when the legacy report channel uses another bot; same-bot reports and trading kinds
- *  keep the legacy report destination. Returns null when no safe target is configured. */
+/** An exact role channel wins. A configured channels table cannot silently fall through
+ *  to the legacy report bot or a channel with a different role. Without that table, only
+ *  named finance kinds can use the legacy trading report channel. */
 export function resolveReportTarget(cfg: UserConfig, kind?: string): ReportTarget | null {
-  const routed = kindRouteTarget(cfg, kind);
-  if (routed) return routed;
+  if (cfg.telegram.channels?.length) {
+    const routed = kindRouteTarget(cfg, kind);
+    if (routed) return routed;
+    logKindRouteFallback(kind, 'none', false);
+    return null;
+  }
   const rc = cfg.telegram.reportChannel;
   const mainToken = resolveChannelBotToken('telegram', cfg).token;
   const sameBot = !!mainToken && !!rc && (rc.botToken ?? mainToken) === mainToken;
-  if (isOperationalKind(kind) && !sameBot) {
+  if (!isTradingKind(kind)) {
     const home = mainHomeTarget(cfg);
     logKindRouteFallback(kind, home ? 'main-home' : 'none', sameBot);
     return home;
   }
-  const botToken = rc?.botToken ?? mainToken;
-  const target = rc && Number.isFinite(rc.chatId) && botToken ? { botToken, chatId: rc.chatId } : null;
+  const botToken = rc?.botToken;
+  const target = rc && Number.isFinite(rc.chatId) && botToken && botToken !== mainToken
+    ? { botToken, chatId: rc.chatId } : null;
   logKindRouteFallback(kind, target ? 'report-channel' : 'none', sameBot);
   return target;
 }
@@ -81,10 +86,9 @@ export interface SendReportOpts {
   kind?: string;
 }
 
-/** Send a report to the configured report channel. Returns false (a
- *  no-op, never throws) when no report channel is configured, so callers
- *  can fire-and-forget without gating on config. Throws only on an actual
- *  Telegram API failure once a target exists. */
+/** Send a report to its kind's exact-role channel (or the safe legacy target).
+ *  Returns false when no safe target exists; throws only on an actual
+ *  Telegram API failure after a target has been selected. */
 export async function sendTelegramReport(
   cfg: UserConfig,
   text: string,
@@ -110,9 +114,9 @@ export async function sendTelegramReport(
 export async function sendReportPhoto(
   cfg: UserConfig,
   photoUrl: string,
-  opts: { caption?: string; fetchImpl?: typeof fetch } = {},
+  opts: { caption?: string; fetchImpl?: typeof fetch; kind?: string } = {},
 ): Promise<boolean> {
-  const target = resolveReportTarget(cfg);
+  const target = resolveReportTarget(cfg, opts.kind);
   if (!target || !photoUrl) return false;
   const bot = new TelegramBot({
     token: target.botToken,
@@ -131,9 +135,9 @@ export async function sendReportPhoto(
 export async function sendReportPhotoBuffer(
   cfg: UserConfig,
   png: Buffer,
-  opts: { caption?: string; fetchImpl?: typeof fetch } = {},
+  opts: { caption?: string; fetchImpl?: typeof fetch; kind?: string } = {},
 ): Promise<boolean> {
-  const target = resolveReportTarget(cfg);
+  const target = resolveReportTarget(cfg, opts.kind);
   if (!target || !png) return false;
   const bot = new TelegramBot({
     token: target.botToken,

package/src/telegram.ts

@@ -25,6 +25,7 @@ import { randomUUID } from 'node:crypto';
 import { buildTurnOutputTextBlocks } from './input/turn-output-block.js';
 import { selectTurnOutputTextForSink } from './input/turn-output-sink-registry.js';
 import { debug } from './debug/log.js';
+import { botAudienceFor, filterBotCommands, readBotAudience } from './maturity/bot-command-maturity.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 import type { TelegramVoiceAdapter } from './voice/channel-adapters/telegram-voice-adapter.js';
 import { createTelegramSurfaceHitl, type TelegramSurfaceHitl } from './hitl/telegram-surface-hitl.js';
@@ -67,6 +68,7 @@ import { runUrlRoute } from './skills/url-route-exec.js';
 import { recordRoutedLinkAbsorbed } from './intake-plane/link-ledger.js';
 import { classifyFrontInput } from './intake-plane/front-classifier.js';
 import { handleTelegramSeatWork, type TelegramSeatWorkDeps } from './intake-plane/telegram-seat-work.js';
+import { deliverSeatAnswers } from './seat-dispatch/seat-ask.js';
 import { effectiveInstanceRoot } from './instance/resolve.js';
 import { getElanousConfigDir } from './elanous-config-dir.js';
 import { defaultFieldEvent, FieldUploadError, parseFieldCaption, resolveFieldMime, saveFieldMedia } from './field/field-media.js';
@@ -338,6 +340,7 @@ export class TelegramBot {
   private readonly fieldReel?: FieldReelOptions;
   private readonly cardFollowupDeps: Pick<CardPhotoDeps, 'runGraph' | 'rootDir' | 'ocrText'>;
   private readonly seatWorkDeps: TelegramSeatWorkDeps;
+  private seatAskTimer: ReturnType<typeof setInterval> | null = null;
   /** 앨범 id → `#현장` 행사 · 답장 디바운스. 태그된 앨범만 들어온다. */
   private readonly fieldGroups = new Map<string, {
     event: string; mode?: 'instant'; at: number; chatId: number; threadId?: number; replyTo: number; count: number;
@@ -373,7 +376,15 @@ export class TelegramBot {
     this.fieldRootDir = opts.fieldRootDir ?? getElanousConfigDir;
     this.fieldReel = opts.fieldReel;
     this.cardFollowupDeps = opts.cardFollowupDeps ?? {};
-    this.seatWorkDeps = opts.seatWorkDeps ?? {};
+    this.seatWorkDeps = { ...opts.seatWorkDeps, askDeps: { ...opts.seatWorkDeps?.askDeps,
+      channel: 'telegram', botId: this.botId,
+      send: opts.seatWorkDeps?.askDeps?.send ?? (async (origin, text) => {
+        if (origin.channel !== 'telegram') throw new Error('seat ask belongs to another surface');
+        const posted = await this.sendMessage(Number(origin.chatId), text, { replyTo: origin.messageId, threadId: origin.threadId });
+        if (!posted) throw new Error('Telegram seat ask reply was not posted');
+      }),
+    } };
+
     if (opts.onTriggerTap) {
       // Assign through `as unknown` to bypass `readonly` + private —
       // the tap is set once at construction and never reassigned.
@@ -1120,6 +1131,9 @@ export class TelegramBot {
   async start(): Promise<void> {
     this.running = true;
     this.log(`telegram 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);
     if (this.allowedUsers.size === 0) this.log('telegram.owner-gate empty-allowlist');
 
     // Publish the slash-command menu to Telegram. Clients pick up the
@@ -1128,9 +1142,16 @@ export class TelegramBot {
     // still processes `/commands` via the incoming-message dispatch
     // path, users just don't get the autocomplete.
     if (this.slashCommands.length > 0) {
+      const audience = this.slashContext
+        ? readBotAudience((this.slashContext.userConfig.raw?.telegram as { commandAudience?: unknown } | undefined)?.commandAudience)
+        : botAudienceFor('telegram');
+      const commands = filterBotCommands('telegram', this.slashCommands, audience);
+      debug.log('telegram.command', 'menu-filtered', {
+        total: this.slashCommands.length, shown: commands.length, ...audience,
+      });
       try {
         const result = await this.apiCall<unknown>('setMyCommands', {
-          commands: toTelegramBotCommands(this.slashCommands),
+          commands: toTelegramBotCommands(commands),
         });
         debug.log('telegram.command', 'published', { success: true, result });
         this.log(`telegram: setMyCommands published (${String(result)})`);
@@ -1151,6 +1172,7 @@ export class TelegramBot {
     const CONFLICT_BACKOFF_CAP = 60_000;
     while (this.running) {
       try {
+        await deliverSeatAnswers(this.seatWorkDeps.askDeps!);
         const wantCallbackQuery = this.callbackHandlers.size > 0;
         const wantReaction = this.reactionHandlers.size > 0;
         // allowed_updates 는 명시한 것만 받으므로 등록된 핸들러 종류만 추가(비파괴 — 핸들러
@@ -1292,7 +1314,11 @@ export class TelegramBot {
     this.log('telegram bot stopped');
   }
 
-  stop(): void { this.running = false; }
+  stop(): void {
+    this.running = false;
+    if (this.seatAskTimer) clearInterval(this.seatAskTimer);
+    this.seatAskTimer = null;
+  }
 
   /** Download + normalize this message's attachments into the shape
    *  the ACP content-blocks module consumes. Called lazily by slash

package/src/tool-runtime/self-cognition-runtimes.ts

@@ -11,6 +11,7 @@ export const SELF_COGNITION_TOOL_NAMES = [
   'logs_query',
   'ops_status',
   'memory_recall',
+  'context_now',
 ] as const;
 
 type SelfCognitionToolName = (typeof SELF_COGNITION_TOOL_NAMES)[number];
@@ -23,7 +24,14 @@ function coreTools(): CoreToolsModule {
   return require('../domains/core-tools.js') as CoreToolsModule;
 }
 
+export const CONTEXT_NOW_SPEC: LLMToolSpec = {
+  name: 'context_now',
+  description: '지금 무엇이 돌고 있는지 릴리스 칸·열린 결정·자리 원장·최근 맥락 이벤트의 출처 있는 요약을 읽는다. 원문 대화는 반환하지 않는다.',
+  parameters: { type: 'object', properties: { topic: { type: 'string', description: '칸 id·제목 또는 이벤트 요약에 들어 있는 낱말(선택).' } }, required: [] },
+};
+
 function coreSpec(name: SelfCognitionToolName): LLMToolSpec {
+  if (name === 'context_now') return CONTEXT_NOW_SPEC;
   const spec = coreTools().CORE_TOOL_SPECS.find(candidate => candidate.name === name);
   if (!spec) throw new Error(`Missing core tool spec for self-cognition runtime '${name}'`);
   return spec;
@@ -193,9 +201,11 @@ export const SELF_COGNITION_RUNTIMES: readonly ToolRuntime[] = SELF_COGNITION_TO
   get spec() {
     return coreSpec(name);
   },
-  run: async (args, ctx) => name === 'memory_recall' || name === 'self_recall'
-    ? runRecall(name, args, ctx)
-    : toToolRunResult(await coreTools().buildCoreTools().dispatch(name, args)),
+  run: async (args, ctx) => name === 'context_now'
+    ? (await import('../context-bus/context-now.js')).contextNow({ ...(typeof args.topic === 'string' ? { topic: args.topic } : {}) })
+    : name === 'memory_recall' || name === 'self_recall'
+      ? runRecall(name, args, ctx)
+      : toToolRunResult(await coreTools().buildCoreTools().dispatch(name, args)),
 }));
 
 /** MCP catalog metadata derived from the same name ledger as the runtimes. */