elanous 0.2.9 → 0.2.11

package/src/telegram-card-followup.ts

@@ -0,0 +1,153 @@
+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 { runGraph } from './graph-runner/runner.js';
+import { cardShape, detectCard, runCardFollowup, NotACardError, type CardDetectDecision } from './card-followup/core.js';
+import type { TgIncoming } from './telegram.js';
+
+// 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). */
+const startedAlbums = new Map<string, number>();
+const ALBUM_TTL_MS = 10 * 60_000;
+function firstOfAlbum(chatId: number, mediaGroupId: string | undefined, now: number): boolean {
+  if (!mediaGroupId) return true;
+  for (const [key, at] of startedAlbums) if (now - at > ALBUM_TTL_MS) startedAlbums.delete(key);
+  const key = `${chatId}:${mediaGroupId}`;
+  if (startedAlbums.has(key)) return false;
+  startedAlbums.set(key, now);
+  return true;
+}
+
+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> {
+  if (process.platform !== 'darwin') return Promise.resolve(null);
+  return new Promise((done) => {
+    let out = '';
+    let child: ReturnType<typeof spawn>;
+    try { child = spawn('swift', [OCR_SCRIPT, path], { stdio: ['ignore', 'pipe', 'ignore'] }); } catch { done(null); return; }
+    const timer = setTimeout(() => { child.kill('SIGKILL'); done(null); }, timeoutMs);
+    child.stdout?.on('data', (chunk) => { out += String(chunk); });
+    child.once('error', () => { clearTimeout(timer); done(null); });
+    child.once('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) { done(null); return; }
+      done(out.split('\n').map((l) => /^\s+[\d.]+\s+(.*?)\s+box=/.exec(l)?.[1]).filter(Boolean).join('\n'));
+    });
+  });
+}
+
+type Picked = 'all' | 'strategy' | 'draft' | 'crm';
+export interface CardPhotoDeps {
+  isOwner: (userId: number) => boolean;
+  isFieldAlbum?: (id: string) => boolean;
+  downloadFile: (fileId: string, destDir: string) => Promise<{ localPath: string }>;
+  sendMessage: (chatId: number, text: string, opts: { replyTo: number; threadId?: number }) => Promise<unknown>;
+  sendDocument: (chatId: number, body: string | Buffer, filename: string, opts: { replyTo: number; threadId?: number; mimeType?: string }) => Promise<unknown>;
+  runGraph?: typeof runGraph;
+  rootDir?: () => string;
+  /** OCR text of a downloaded photo, or null when unavailable (default: local macOS Vision). */
+  ocrText?: (path: string) => Promise<string | null>;
+}
+
+function pick(caption: string): Picked {
+  if (/\bCRM\b/i.test(caption)) return 'crm';
+  if (/메일\s*초안|초안/i.test(caption)) return 'draft';
+  if (/전략/.test(caption)) return 'strategy';
+  return 'all';
+}
+
+/** Starts a private graph run without blocking the Telegram message turn. */
+export async function maybeHandleCardPhoto(ctx: TgIncoming, deps: CardPhotoDeps): Promise<boolean> {
+  const photo = ctx.attachments.find((att) => att.kind === 'photo');
+  const caption = ctx.text.trim();
+  if (!ctx.isDm || ctx.isGroup || !deps.isOwner(ctx.userId) || !photo
+    || (ctx.mediaGroupId && deps.isFieldAlbum?.(ctx.mediaGroupId))
+    || /#현장/.test(caption) || (caption && !KEYWORD.test(caption))) return false;
+  const detect = (decision: CardDetectDecision, signal: string) =>
+    debug.log('telegram.card-followup', 'detect', { chatId: ctx.chatId, decision, signal });
+  if (!caption) {
+    const shape = cardShape(photo.width, photo.height);
+    if (shape.decision === 'skip') { detect('skip', shape.signal); return false; }
+  }
+  // Album items after the first: a keyword caption sits on one item only, so later items follow the normal flow.
+  if (!firstOfAlbum(ctx.chatId, ctx.mediaGroupId, Date.now())) return false;
+
+  const picked = pick(caption);
+  const started = Date.now();
+  const reply = { replyTo: ctx.messageId, ...(ctx.threadId === undefined ? {} : { threadId: ctx.threadId }) };
+  const log = (event: 'started' | 'not-a-card' | 'replied' | 'failed') =>
+    debug.log('card.followup', event, { chatId: ctx.chatId, picked, ms: Date.now() - started });
+
+  try {
+    const root = (deps.rootDir ?? effectiveInstanceRoot)();
+    const base = join(root, 'graph-runs', 'card-followup');
+    const runId = randomUUID();
+    const dir = join(base, runId);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(base, 0o700);
+    chmodSync(dir, 0o700);
+    const prepare = async (): Promise<string | null> => {
+      const { localPath } = await deps.downloadFile(photo.fileId, dir);
+      chmodSync(localPath, 0o600);
+      if (!caption) {
+        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; }
+      }
+      log('started');
+      await deps.sendMessage(ctx.chatId, '명함으로 보고 정리하는 중입니다(1~3분)', reply);
+      return localPath;
+    };
+    // A keyword caption is an explicit request: download before returning. A bare photo is judged in the background.
+    const prepared = caption ? await prepare() : null;
+    void (async () => {
+      let localPath = prepared;
+      try {
+        if (!caption) {
+          try { localPath = await prepare(); } catch { log('failed'); return; }
+          if (!localPath) 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;
+        }
+        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' ? [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');
+        log('replied');
+      } catch {
+        log('failed');
+        try {
+          await deps.sendMessage(ctx.chatId, '명함 정리에 실패했습니다. 다시 시도해 주세요.', reply);
+        } catch { /* Telegram delivery itself failed; the failure is already observed. */ }
+      }
+    })();
+  } catch {
+    log('failed');
+    // A bare photo was never claimed as a card — failing to prepare it stays silent.
+    if (caption) {
+      try {
+        await deps.sendMessage(ctx.chatId, '명함 정리에 실패했습니다. 다시 시도해 주세요.', reply);
+      } catch { /* Telegram delivery itself failed; the failure is already observed. */ }
+    }
+  }
+  return !!caption;
+}

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 { kindRouteTarget } 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,18 +51,29 @@ export interface ReportTarget {
   chatId: number;
 }
 
-/** Resolve the send target. With a purpose `kind` that maps to a role and explicit `telegram.channels`,
- *  the channel holding that role wins (fallback: the `default` channel). Otherwise the legacy report
- *  channel: `botToken` falls back to the main Q&A bot token when the report channel is served by the
- *  same bot. Returns null when nothing 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;
-  if (!rc || !Number.isFinite(rc.chatId)) return null;
-  const botToken = rc.botToken ?? resolveChannelBotToken('telegram', cfg)?.token;
-  if (!botToken) return null;
-  return { botToken, chatId: rc.chatId };
+  const mainToken = resolveChannelBotToken('telegram', cfg).token;
+  const sameBot = !!mainToken && !!rc && (rc.botToken ?? mainToken) === mainToken;
+  if (!isTradingKind(kind)) {
+    const home = mainHomeTarget(cfg);
+    logKindRouteFallback(kind, home ? 'main-home' : 'none', sameBot);
+    return home;
+  }
+  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;
 }
 
 export interface SendReportOpts {
@@ -75,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,
@@ -104,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,
@@ -125,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-run.ts

@@ -18,6 +18,7 @@ import { effectiveInstanceRoot } from './instance/resolve.js';
 import { getUserConfig } from './user-config.js';
 import { resolveChannelBotToken } from './channel-bot-token.js';
 import { forwardTelegramDispatch } from './telegram-dispatch-forward.js';
+import { mergeCapturedPath, warmCapturedEnv } from './shell-env-bootstrap.js';
 import type { NexusTelegramQaPollerWireHandle } from './nexus/index.js';
 
 export interface TelegramRunResult {
@@ -138,7 +139,13 @@ export async function runTelegramPoller(deps: {
   alert?: (text: string, kind: string) => boolean;
   wait?: () => Promise<void>;
   registerLogSink?: () => Promise<void>;
+  warm?: () => Promise<boolean>;
 } = {}): Promise<void> {
+  void (deps.warm ?? warmCapturedEnv)().then((ok) => {
+    if (ok) mergeCapturedPath();
+  }).catch((error) => {
+    debug.log('shell.envbootstrap.capture', 'warm-failed', { error: String(error) });
+  });
   try {
     if (deps.registerLogSink) await deps.registerLogSink();
     else {

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,10 +68,12 @@ 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';
 import { scheduleFieldReel, type FieldReelOptions } from './field/field-reel.js';
+import { maybeHandleCardPhoto, type CardPhotoDeps } from './telegram-card-followup.js';
 
 export type TgAttachmentKind = 'photo' | 'voice' | 'audio' | 'document';
 
@@ -216,6 +219,8 @@ export interface TelegramBotOpts {
   fieldRootDir?: () => string;
   /** 시험에서는 실제 렌더 대신 가짜 실행기를 주입한다. */
   fieldReel?: FieldReelOptions;
+  /** Test seam for the business-card graph and its private run root. */
+  cardFollowupDeps?: Pick<CardPhotoDeps, 'runGraph' | 'rootDir' | 'ocrText'>;
 }
 
 /** Surface-unification v2 (FU-2) — Telegram trigger event passed to
@@ -333,10 +338,12 @@ export class TelegramBot {
   private readonly fieldDefaultEventOpt?: string;
   private readonly fieldRootDir: () => string;
   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; at: number; chatId: number; threadId?: number; replyTo: number; count: number;
+    event: string; mode?: 'instant'; at: number; chatId: number; threadId?: number; replyTo: number; count: number;
     timer?: ReturnType<typeof setTimeout>;
   }>();
 
@@ -368,7 +375,16 @@ export class TelegramBot {
     this.fieldDefaultEventOpt = opts.fieldDefaultEvent;
     this.fieldRootDir = opts.fieldRootDir ?? getElanousConfigDir;
     this.fieldReel = opts.fieldReel;
-    this.seatWorkDeps = opts.seatWorkDeps ?? {};
+    this.cardFollowupDeps = opts.cardFollowupDeps ?? {};
+    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.
@@ -376,7 +392,7 @@ export class TelegramBot {
     }
   }
 
-  private isOwnerAllowed(userId: number): boolean {
+  isOwnerAllowed(userId: number): boolean {
     return this.allowedUsers.size > 0 && this.allowedUsers.has(userId);
   }
 
@@ -1115,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
@@ -1123,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)})`);
@@ -1146,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 는 명시한 것만 받으므로 등록된 핸들러 종류만 추가(비파괴 — 핸들러
@@ -1287,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
@@ -1415,6 +1446,10 @@ export class TelegramBot {
       ? tag.event ?? defaultFieldEvent(
         this.fieldDefaultEventOpt ?? this.slashContext?.userConfig?.telegram?.fieldDefaultEvent, new Date(now))
       : group!.event;
+    const captionMode = tag?.mode ?? group?.mode;
+    const configMode = this.slashContext?.userConfig?.telegram?.fieldReelMode;
+    const mode = captionMode ?? configMode ?? 'standard';
+    const source = captionMode ? 'caption' : configMode ? 'config' : 'default';
 
     let count: number | null = null;
     let failure: string | null = null;
@@ -1435,14 +1470,16 @@ export class TelegramBot {
       // 글(자막)은 캡션이 달린 항목에만 있다 — 앨범이면 첫 장에만 붙는다(MK 2026-09-30).
       const saved = saveFieldMedia(inputs, { rootDir: this.fieldRootDir(), event, device: 'telegram', ...(tag?.text ? { caption: tag.text } : {}) });
       count = saved.count;
+      debug.log('telegram.field', 'reel-mode', { event, mode, source });
       scheduleFieldReel(saved.dir, {
         ...this.fieldReel,
+        mode,
         notificationKey: `telegram:${this.botId}:${ctx.chatId}:${ctx.threadId ?? ''}:${ctx.mediaGroupId ?? ctx.messageId}`,
         onDone: async (result) => {
           const reply = { replyTo: ctx.messageId, threadId: ctx.threadId };
           if (result.ok && result.file) {
             const sent = await this.sendDocument(ctx.chatId, readFileSync(result.file), 'reel-9x16.mp4', {
-              ...reply, mimeType: 'video/mp4', caption: `현장 영상 · ${event} · ${result.seconds}초`,
+              ...reply, mimeType: 'video/mp4', caption: `현장 영상 · ${event} · ${result.seconds}초${mode === 'instant' ? ' (즉석판)' : ''}`,
             });
             if (!sent) throw new Error('sendDocument failed');
             if (result.feed?.started) {
@@ -1469,7 +1506,8 @@ export class TelegramBot {
       return true;
     }
     // 앨범은 항목마다 답하지 않는다 — 마지막 항목 뒤 한 번(디바운스)만 최신 수로 답한다.
-    const entry = group ?? { event, at: now, chatId: ctx.chatId, threadId: ctx.threadId, replyTo: ctx.messageId, count: 0 };
+    const entry = group ?? { event, mode: tag?.mode, at: now, chatId: ctx.chatId, threadId: ctx.threadId, replyTo: ctx.messageId, count: 0 };
+    if (group && tag?.mode) group.mode = tag.mode;
     entry.at = now;
     entry.count = count!;
     if (entry.timer) clearTimeout(entry.timer);
@@ -1490,10 +1528,18 @@ export class TelegramBot {
     }
     // 현장 업로드 — `#현장` 캡션(또는 태그된 앨범의 나머지)의 사진·영상은 LLM 대신 현장 폴더로.
     if (await this.tryHandleFieldUpload(ctx)) return;
-    if (ctx.text.startsWith('@')) {
+    if (await maybeHandleCardPhoto(ctx, {
+      isOwner: (userId) => this.isOwnerAllowed(userId),
+      isFieldAlbum: (id) => this.fieldGroups.has(id),
+      downloadFile: (fileId, dir) => this.downloadFile(fileId, dir),
+      sendMessage: (chatId, text, opts) => this.sendMessage(chatId, text, opts),
+      sendDocument: (chatId, body, filename, opts) => this.sendDocument(chatId, body, filename, opts),
+      ...this.cardFollowupDeps,
+    })) return;
+    if (ctx.text.startsWith('@') || (ctx.isDm && ctx.text && !ctx.text.startsWith('/'))) {
       const reply = await handleTelegramSeatWork(ctx.text, {
-        chatId: ctx.chatId, messageId: ctx.messageId, threadId: ctx.threadId, botId: ctx.botId,
-      }, this.seatWorkDeps);
+        chatId: ctx.chatId, userId: ctx.userId, messageId: ctx.messageId, threadId: ctx.threadId, botId: ctx.botId,
+      }, { ...this.seatWorkDeps, config: this.seatWorkDeps.config ?? this.slashContext?.userConfig });
       if (reply !== null) {
         await this.sendMessage(ctx.chatId, reply, { replyTo: ctx.messageId, threadId: ctx.threadId });
         return;
@@ -1529,7 +1575,7 @@ export class TelegramBot {
       try {
         const { addDirective } = await import('./steward/directive.js');
         const text = ctx.text.startsWith('지시:') ? ctx.text.slice('지시:'.length) : ctx.text.slice('/directive '.length);
-        const result = await addDirective(text, { source: 'telegram' });
+        const result = await addDirective(text, { source: 'telegram', origin: { chatId: ctx.chatId, botId: ctx.botId, threadId: ctx.threadId } });
         await this.sendMessage(ctx.chatId, `${result.issue}: ${result.status}`, { replyTo: ctx.messageId, threadId: ctx.threadId });
       } catch {
         await this.sendMessage(ctx.chatId, '지시 등록 실패 — Linear 연결과 자격을 확인하세요.', { replyTo: ctx.messageId, threadId: ctx.threadId });
@@ -2746,6 +2792,7 @@ export function botFromConfig(opts: BotFromConfigOpts): TelegramBot {
         // (makeTelegramAgentRunTurn) threads it into `delegate_code_agent`
         // so a delegated sub-agent's approval prompt lands back here.
         hitlConfirmChannel: botRef.hitlConfirmChannelForChat(ctx.chatId, ctx.threadId),
+        ...(botRef.isOwnerAllowed(ctx.userId) ? { verifiedOwner: { id: `telegram:${ctx.userId}` } } : {}),
         hitlQuestionChannel: botRef.hitlQuestionChannelForChat(ctx.chatId, ctx.threadId),
         // P1.4 — surface file spill bound to THIS chat so the NL
         // `delegate_code_agent` path spills big diffs/stdout back here.

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. */

package/src/tool-runtime/types.ts

@@ -91,8 +91,12 @@ export interface ToolRuntimeContext {
   sessionId?: string;
   /** Session that originated this execution when it was delegated through another runtime session. */
   originSessionId?: string;
+  /** Server-verified owner principal. Never derive this from session source, tool args, or a client-declared origin. */
+  verifiedOwner?: { id: string };
   /** Server-assigned provenance; omitted on existing owner tool paths. */
   requestOrigin?: RequestOrigin;
+  /** Confirm through the originating chat's channels, not another user's global channel. */
+  confirmChannels?: import('../hitl/confirm.js').ConfirmChannel[];
 }
 
 /** Output shape the LLM layer expects back. Most tools produce

package/src/tui-client/dashboard-session.ts

@@ -210,6 +210,8 @@ export class DashboardSession {
       transportFactory: pair.transportFactory,
       shutdownSignal: shutdownCtrl.signal,
       runTurn,
+      // PCH-2b — the in-process TUI dispatcher carries its own approval modals.
+      toolApproval: 'off',
       ...(opts.agentName ? { agentName: opts.agentName } : {}),
       ...(opts.agentVersion ? { agentVersion: opts.agentVersion } : {}),
       ...(opts.serverOptions ?? {}),