elanous 0.2.10 → 0.2.12

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,12 @@ 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 { createWishCard } from './intake-plane/wish-card.js';
+import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
+import { CardStore } from './task-cards/card-store.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
@@ -152,6 +158,7 @@ export interface TgCommandContext {
   userConfig: UserConfig;
   /** All registered commands — used by `/help` to enumerate. */
   allCommands: TgSlashCommand[];
+  sendButtons?: (text: string, buttons: Array<Array<{ text: string; data: string }>>) => Promise<void>;
   /** When the caller posted a placeholder for a streaming command,
    *  the streamer edits it in-place as the handler accumulates
    *  output. Undefined for instant commands. Handlers must tolerate
@@ -291,7 +298,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 +311,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 +593,24 @@ export function defaultTelegramCommands(): TgSlashCommand[] {
         return lines.join('\n');
       },
     },
+    projectCommand(),
+    {
+      name: 'wish',
+      description: '소원을 카드로 남기기',
+      handler: async (args, ctx, { userConfig }) => {
+        if (String(ctx.userId) !== telegramDecisionOwner(userConfig) || ctx.chatId !== ctx.userId || !ctx.isDm) {
+          return '대표만 쓸 수 있습니다';
+        }
+        if (args.length === 0) return '/wish <소원 한 줄>';
+        const store = new CardStore();
+        try {
+          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}` }, store);
+          return `소원 카드로 남겼습니다 — ${card.title} (카드 ${card.cardId.slice(0, 8)})`;
+        } finally {
+          store.close();
+        }
+      },
+    },
     {
       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,145 @@
+import { debug } from './debug/log.js';
+import { getProject, listProjects, type Project } from './project/project-store.js';
+import { findSessionByTelegramChat, updateSessionMeta } from './session/index.js';
+import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
+import type { TelegramBot } from './telegram.js';
+import type { TgSlashCommand } from './telegram-commands.js';
+import type { UserConfig } from './user-config.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, ctxOptions) => {
+      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));
+        debug.log('telegram.project', 'listed', { projects: projects.slice(0, 20).map(p => ({ id: p.id, name: p.name })) });
+        if (ctx.isDm && ctx.chatId === ctx.userId
+          && String(ctx.userId) === telegramDecisionOwner(ctxOptions.userConfig) && ctxOptions.sendButtons) {
+          const buttons = projects.filter(p => {
+            const bytes = Buffer.byteLength(`prj:${p.id}`, 'utf8');
+            if (bytes <= 64) return true;
+            debug.log('telegram.project', 'button-rejected', { reason: 'callback-data-too-long', projectId: p.id, bytes });
+            return false;
+          }).slice(0, 8).map(p => ({ text: p.name, data: `prj:${p.id}` }));
+          buttons.push({ text: '받은 대화로', data: 'prj:-' });
+          const rows: Array<Array<{ text: string; data: string }>> = [];
+          for (let i = 0; i < buttons.length; i += 2) rows.push(buttons.slice(i, i + 2));
+          try {
+            await ctxOptions.sendButtons('프로젝트를 선택하세요', rows);
+          } catch (err) {
+            debug.log('telegram.project', 'button-rejected', {
+              reason: 'send-failed', error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
+        return [
+          `지금 대화의 프로젝트: ${current?.name ?? '받은 대화(프로젝트 없음)'}`,
+          '',
+          '프로젝트 목록:',
+          ...projects.slice(0, 20).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} 프로젝트로 옮겼습니다`;
+    },
+  };
+}
+
+export function attachTelegramProjectButtons(
+  bot: Pick<TelegramBot, 'botId' | 'onCallbackQuery' | 'sendMessage' | 'answerCallbackQuery'>,
+  cfg: UserConfig,
+  deps: TelegramProjectCommandDeps = {
+    list: listProjects,
+    find: getProject,
+    update: updateSessionMeta,
+    findSession: findSessionByTelegramChat,
+  },
+): () => void {
+  const owner = telegramDecisionOwner(cfg);
+  return bot.onCallbackQuery(async q => {
+    if (!q.data.startsWith('prj:')) return;
+    if (!owner || String(q.userId) !== owner) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-owner', userId: q.userId, chatId: q.chatId });
+      await bot.answerCallbackQuery(q.id, { text: '권한이 없습니다' });
+      return;
+    }
+    if (q.chatId === undefined || q.chatId !== q.userId || q.threadId !== undefined) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-private-chat', userId: q.userId, chatId: q.chatId });
+      await bot.answerCallbackQuery(q.id, { text: '개인 대화에서만 고를 수 있습니다' });
+      return;
+    }
+    const chatId = q.chatId;
+    const session = deps.findSession(chatId, q.threadId, bot.botId);
+    if (!session) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'no-session', chatId });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '아직 이 채팅에 대화가 없습니다 — 한 마디 보낸 뒤 다시');
+      return;
+    }
+    if (q.data === 'prj:-') {
+      deps.update(session.id, m => { delete m.projectId; });
+      debug.log('telegram.project', 'button-cleared', { chatId, sessionId: session.id });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '받은 대화로 옮겼습니다');
+      return;
+    }
+    const project = deps.find(q.data.slice(4));
+    if (!project) {
+      debug.log('telegram.project', 'button-rejected', { reason: 'not-found', chatId, projectId: q.data.slice(4) });
+      await bot.answerCallbackQuery(q.id);
+      await bot.sendMessage(chatId, '그 이름의 프로젝트가 없습니다 — /project 로 목록 보기');
+      return;
+    }
+    deps.update(session.id, m => { m.projectId = project.id; });
+    debug.log('telegram.project', 'button-moved', { chatId, sessionId: session.id, projectId: project.id });
+    await bot.answerCallbackQuery(q.id);
+    await bot.sendMessage(chatId, `이 대화를 ${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,