elanous 0.2.8 → 0.2.10

package/src/telegram-run.ts

@@ -11,9 +11,14 @@
 // - 워크플로 트리거는 core 의 `POST /v1/workflows/telegram-dispatch` 로 넘긴다(`telegram-dispatch-forward.ts`).
 
 import { debug } from './debug/log.js';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+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 {
@@ -55,10 +60,10 @@ export function setTelegramPollLockForTesting(deps: typeof pollLockForTesting):
 /** 폴러를 띄우고 핸들을 돌려준다(시험용으로 분리 — 대기는 `runTelegramPoller` 가 한다). */
 export async function startTelegramPollers(): Promise<TelegramRunResult> {
   const cfg = getUserConfig();
-  const mainToken = resolveChannelBotToken('telegram', cfg)?.token;
-  if (!cfg.telegram.enabled || !mainToken) {
-    throw new Error('telegram run: telegram.enabled 가 꺼져 있거나 bot token 이 없다');
-  }
+  if (cfg.telegram.enabled === false) throw new Error('telegram run: telegram.enabled 가 꺼져 있다');
+  const resolved = resolveChannelBotToken('telegram', cfg);
+  if (!resolved.token) throw new Error(`telegram run: bot token 못 풂 — ${resolved.reason}`);
+  const mainToken = resolved.token;
   if (cfg.telegram.poller !== 'standalone') {
     console.warn('[telegram run] ⚠️ telegram.poller 가 standalone 이 아니다 — 넥서스도 같은 토큰을 폴링하려 한다. 토큰 잠금이 먼저 잡은 쪽만 띄운다.');
   }
@@ -105,25 +110,97 @@ export async function startTelegramPollers(): Promise<TelegramRunResult> {
   return { started, refusedBotIds, late };
 }
 
-/** SIGINT/SIGTERM 까지 돈다. */
-export async function runTelegramPoller(): Promise<void> {
+function failurePath(): string { return join(effectiveInstanceRoot(), 'telegram', 'run-failures.json'); }
+
+function failureState(): { count: number; alerted: boolean } {
+  const path = failurePath();
+  if (!existsSync(path)) return { count: 0, alerted: false };
+  const data: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!data || typeof data !== 'object' || !('count' in data) || !Number.isSafeInteger(data.count)
+    || (data.count as number) < 0 || ('alerted' in data && typeof data.alerted !== 'boolean')) {
+    throw new Error(`invalid telegram run failures at ${path}`);
+  }
+  return { count: data.count as number, alerted: 'alerted' in data ? data.alerted as boolean : false };
+}
+
+function writeFailureState(count: number, alerted: boolean): void {
+  const path = failurePath();
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify({ count, alerted }), { mode: 0o600, flag: 'wx' });
+    renameSync(tmp, path);
+  } finally { if (existsSync(tmp)) unlinkSync(tmp); }
+}
+
+/** SIGINT/SIGTERM 까지 돈다. Failure exit policy is tested without a live poller. */
+export async function runTelegramPoller(deps: {
+  start?: typeof startTelegramPollers;
+  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 {
-    const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
-    await registerStandaloneLogSink('telegram-run');
+    if (deps.registerLogSink) await deps.registerLogSink();
+    else {
+      const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
+      await registerStandaloneLogSink('telegram-run');
+    }
   } catch (e) {
     console.error(`[telegram run] ⚠️ 로그 싱크 등록 실패(관측 유실 가능): ${e instanceof Error ? e.message : String(e)}`);
   }
   console.log('[telegram run] 토큰 잠금을 잡는 중 (토큰마다 최대 30초)…');
-  const { started, refusedBotIds, late } = await startTelegramPollers();
+  let result: TelegramRunResult;
+  try {
+    if (!deps.start) {
+      const [{ registerAllCloudBackends }, { selectBackendFromConfig }] = await Promise.all([
+        import('./nexus/config/secrets/register-cloud.js'), import('./nexus/config/secrets/registry.js'),
+      ]);
+      registerAllCloudBackends();
+      selectBackendFromConfig();
+    }
+    result = await (deps.start ?? startTelegramPollers)();
+    if (result.started.length === 0) throw new Error('telegram run: 띄운 폴러가 없다');
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : 'unknown start failure';
+    const previous = failureState();
+    const count = previous.count + 1;
+    writeFailureState(count, previous.alerted);
+    debug.log('telegram.run', 'start-failed', { count, reason });
+    if (count >= 3) {
+      if (!previous.alerted) {
+        try {
+          const alert = deps.alert ?? (await import('./domains/outbound-alert.js')).sendOutbound;
+          if (!alert(`텔레그램 폴러가 3번 연속 못 떴다 — ${reason}`, 'alert')) {
+            throw new Error('telegram run: outbound alert not delivered');
+          }
+        } catch (alertError) {
+          debug.log('telegram.run', 'alert-failed', { count, reason });
+          throw alertError;
+        }
+        writeFailureState(count, true);
+        debug.log('telegram.run', 'alerted', { count, reason });
+      }
+      return;
+    }
+    throw error;
+  }
+  const { started, refusedBotIds, late } = result;
+  const path = failurePath();
+  if (existsSync(path)) unlinkSync(path);
   debug.log('telegram.run', 'started', { pid: process.pid, pollers: started.length, refusedBotIds });
   for (const botId of refusedBotIds) {
     console.warn(`[telegram run] 봇 ${botId}: 다른 프로세스가 폴링 중 — 15초마다 다시 잡으러 간다 (elanous logs --category telegram.run)`);
   }
-  // 하나도 못 잡았으면 끝낸다(exit≠0) — 서비스 관리자(launchd KeepAlive·systemd Restart)가 다시 띄운다.
-  if (started.length === 0) throw new Error('telegram run: 띄운 폴러가 없다');
   for (const { channel } of started) console.log(`[telegram run] 채널 '${channel.name}' 폴러 활성 (${channel.botToken.split(':')[0]})`);
   console.log('[telegram run] Ctrl-C 로 멈춘다.');
-  await new Promise<void>((resolve) => {
+  await (deps.wait?.() ?? new Promise<void>((resolve) => {
     const stop = (): void => {
       process.off('SIGINT', stop);
       process.off('SIGTERM', stop);
@@ -135,5 +212,5 @@ export async function runTelegramPoller(): Promise<void> {
     };
     process.on('SIGINT', stop);
     process.on('SIGTERM', stop);
-  });
+  }));
 }

package/src/telegram.ts

@@ -71,6 +71,7 @@ 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 +217,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 +336,11 @@ 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;
   /** 앨범 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,6 +372,7 @@ export class TelegramBot {
     this.fieldDefaultEventOpt = opts.fieldDefaultEvent;
     this.fieldRootDir = opts.fieldRootDir ?? getElanousConfigDir;
     this.fieldReel = opts.fieldReel;
+    this.cardFollowupDeps = opts.cardFollowupDeps ?? {};
     this.seatWorkDeps = opts.seatWorkDeps ?? {};
     if (opts.onTriggerTap) {
       // Assign through `as unknown` to bypass `readonly` + private —
@@ -376,7 +381,7 @@ export class TelegramBot {
     }
   }
 
-  private isOwnerAllowed(userId: number): boolean {
+  isOwnerAllowed(userId: number): boolean {
     return this.allowedUsers.size > 0 && this.allowedUsers.has(userId);
   }
 
@@ -1415,6 +1420,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 +1444,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 +1480,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 +1502,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 +1549,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 +2766,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/thinking-line.ts

@@ -156,6 +156,14 @@ function renderLine(
   return `${applyColor(glyph, 'claude')} ${C.muted(message + '…')}${tail}`;
 }
 
+function stoppedMessage(message: string, status: ThinkingStatus): string {
+  const taskName = message.replace(/^(?:Streaming|Thinking)(?=\b|…)(?:\s*…)?\s*/, '').trim();
+  const task = taskName ? `${taskName} ` : '';
+  if (status === 'completed') return `${task}완료`;
+  if (status === 'interrupted') return `${task}중단됨`;
+  return `${task}실패`;
+}
+
 export function startThinking(opts: StartThinkingOpts): ThinkingHandle {
   let message = opts.message ?? 'Thinking';
   let messageFactory: ((frame: number) => string) | null = null;
@@ -222,20 +230,19 @@ export function startThinking(opts: StartThinkingOpts): ThinkingHandle {
       if (metrics.engine) detail.push(metrics.engine);
       const tail = detail.length ? '  ' + C.muted('(' + detail.join(' · ') + ')') : '';
       let finalText: string;
-      if (stopOpts?.finalText) {
+      if (stopOpts?.finalText !== undefined) {
         finalText = stopOpts.finalText;
-      } else if (status === 'completed') {
-        // Green tick + verb kept visible (not muted) so it stands out.
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(currentMessage)}${tail}`;
-      } else if (status === 'interrupted') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(currentMessage + ' · interrupted')}${tail}`;
       } else {
-        // failed
-        const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
         const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(currentMessage + ' · failed' + err)}${tail}`;
+        const label = stoppedMessage(currentMessage, status);
+        if (status === 'completed') {
+          finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(label)}${tail}`;
+        } else if (status === 'interrupted') {
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(label)}${tail}`;
+        } else {
+          const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(label + err)}${tail}`;
+        }
       }
 
       // Freeze at tail if sticky='tail' — the indicator was tracking
@@ -310,18 +317,19 @@ export function startPinnedThinking(opts: StartPinnedThinkingOpts): ThinkingHand
       if (metrics.engine) detail.push(metrics.engine);
       const tail = detail.length ? '  ' + C.muted('(' + detail.join(' · ') + ')') : '';
       let finalText: string;
-      if (stopOpts?.finalText) {
+      if (stopOpts?.finalText !== undefined) {
         finalText = stopOpts.finalText;
-      } else if (status === 'completed') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(currentMessage)}${tail}`;
-      } else if (status === 'interrupted') {
-        const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(currentMessage + ' · interrupted')}${tail}`;
       } else {
-        const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
         const currentMessage = messageFactory ? messageFactory(frame) : message;
-        finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(currentMessage + ' · failed' + err)}${tail}`;
+        const label = stoppedMessage(currentMessage, status);
+        if (status === 'completed') {
+          finalText = `${applyColor(FIGURES.TICK, 'success')} ${C.success(label)}${tail}`;
+        } else if (status === 'interrupted') {
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.warning(label)}${tail}`;
+        } else {
+          const err = stopOpts?.errorText ? ` — ${stopOpts.errorText}` : '';
+          finalText = `${applyColor(FIGURES.CROSS, 'error')} ${C.error(label + err)}${tail}`;
+        }
       }
       opts.target.current = finalText;
       opts.onFrame();

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/chat/execution-badge.ts

@@ -1,7 +1,7 @@
 // ── TUI TRUE-execution badge (self-cognition §1) ──────────────────────
 //
 // Resolves the compact engine/model badge for the dashboard chat
-// completion line — `✔ Streaming (19s · ↓ 200 tokens · 🧠 terra(high))`.
+// completion line — `✔ 완료 (19s · ↓ 200 tokens · 🧠 terra(high))`.
 // The value is the model that ACTUALLY ran this turn (from the route
 // decision recorded in the ACP bridge's getActiveModel), not the config
 // original — so the "config=opus but codex/terra ran" illusion is

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 ?? {}),