elanous 0.2.4 → 0.2.6

package/src/telegram-report.ts

@@ -11,6 +11,8 @@
 // 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';
+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';
 import { findSessionByTelegramChat, createSession, appendMessage } from './session/index.js';
@@ -49,11 +51,13 @@ export interface ReportTarget {
   chatId: number;
 }
 
-/** Resolve the report-channel send target from config, or null when the
- *  feature is unconfigured. `botToken` falls back to the main Q&A bot
- *  token when the report channel is served by the same bot. Returns null
- *  when neither a report-channel token nor a main token is available. */
-export function resolveReportTarget(cfg: UserConfig): ReportTarget | null {
+/** 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. */
+export function resolveReportTarget(cfg: UserConfig, kind?: string): ReportTarget | null {
+  const routed = kindRouteTarget(cfg, kind);
+  if (routed) return routed;
   const rc = cfg.telegram.reportChannel;
   if (!rc || !Number.isFinite(rc.chatId)) return null;
   const botToken = rc.botToken ?? resolveChannelBotToken('telegram', cfg)?.token;
@@ -67,6 +71,8 @@ export interface SendReportOpts {
   markdown?: boolean;
   /** DI seam for tests — passed through to the send-only TelegramBot. */
   fetchImpl?: typeof fetch;
+  /** Purpose of the message — routes to a channel role (see `DEFAULT_KIND_ROLES`). */
+  kind?: string;
 }
 
 /** Send a report to the configured report channel. Returns false (a
@@ -78,7 +84,7 @@ export async function sendTelegramReport(
   text: string,
   opts: SendReportOpts = {},
 ): Promise<boolean> {
-  const target = resolveReportTarget(cfg);
+  const target = resolveReportTarget(cfg, opts.kind);
   if (!target || !text) return false;
   const bot = new TelegramBot({
     token: target.botToken,

package/src/telegram.ts

@@ -67,6 +67,8 @@ 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 { effectiveInstanceRoot } from './instance/resolve.js';
+import { getElanousConfigDir } from './elanous-config-dir.js';
+import { defaultFieldEvent, FieldUploadError, parseFieldCaption, resolveFieldMime, saveFieldMedia } from './field/field-media.js';
 
 export type TgAttachmentKind = 'photo' | 'voice' | 'audio' | 'document';
 
@@ -105,6 +107,10 @@ export interface TgIncoming {
   botId?: string;
   /** 답장 대상 메시지의 텍스트(force_reply 정정 가로채기용). parseUpdate 가 채운다. */
   replyToText?: string;
+  /** 앨범(media group) id — `#현장` 캡션은 앨범의 첫 항목에만 붙으므로 나머지를 같은 행사로 묶는 데 쓴다. */
+  mediaGroupId?: string;
+  /** 영상 — `#현장` 저장 전용. `attachments` 에 넣지 않는다(LLM 경로의 동작을 안 바꾸려고). */
+  video?: TgIncomingAttachment;
 }
 
 /** Streaming surface passed to the message handler. The handler can
@@ -200,6 +206,10 @@ export interface TelegramBotOpts {
    *  independently of the LLM chat path. Best-effort: errors are
    *  swallowed by the caller — never blocks chat reply. */
   onTriggerTap?: (event: TgTriggerEvent) => void | Promise<void>;
+  /** `#현장` 기본 행사 — 없으면 `slashContext.userConfig.telegram.fieldDefaultEvent` · 그것도 없으면 `field-<로컬 날짜>`. */
+  fieldDefaultEvent?: string;
+  /** 시험 seam — 현장 폴더 뿌리(기본 `getElanousConfigDir()`). */
+  fieldRootDir?: () => string;
 }
 
 /** Surface-unification v2 (FU-2) — Telegram trigger event passed to
@@ -314,6 +324,13 @@ export class TelegramBot {
    *  the bot under Telegram's ~30/sec global cap without blocking
    *  further if load is bursty but average-safe. */
   private readonly globalWindow: number[] = [];
+  private readonly fieldDefaultEventOpt?: string;
+  private readonly fieldRootDir: () => string;
+  /** 앨범 id → `#현장` 행사 · 답장 디바운스. 태그된 앨범만 들어온다. */
+  private readonly fieldGroups = new Map<string, {
+    event: string; at: number; chatId: number; threadId?: number; replyTo: number; count: number;
+    timer?: ReturnType<typeof setTimeout>;
+  }>();
 
   constructor(opts: TelegramBotOpts) {
     if (!opts.token) throw new Error('TelegramBot: token required');
@@ -340,6 +357,8 @@ export class TelegramBot {
     this.slashCommands = opts.slashCommands ?? [];
     this.slashContext = opts.slashContext;
     this.voiceAdapter = opts.voiceAdapter;
+    this.fieldDefaultEventOpt = opts.fieldDefaultEvent;
+    this.fieldRootDir = opts.fieldRootDir ?? getElanousConfigDir;
     if (opts.onTriggerTap) {
       // Assign through `as unknown` to bypass `readonly` + private —
       // the tap is set once at construction and never reassigned.
@@ -1347,11 +1366,82 @@ export class TelegramBot {
     return false;
   }
 
+  /** `#현장` 캡션 사진·영상(이미지·영상 문서 포함)을 현장 폴더에 저장하고 한 줄로 답한다.
+   *  처리했으면 true. 저장 규칙은 HTTP 입구와 같은 `saveFieldMedia` 다. */
+  private async tryHandleFieldUpload(ctx: TgIncoming): Promise<boolean> {
+    const media = [
+      ...ctx.attachments.filter((a) => a.kind === 'photo'
+        || (a.kind === 'document' && resolveFieldMime(a.mimeType, a.fileName ?? '') !== null)),
+      ...(ctx.video ? [ctx.video] : []),
+    ];
+    if (media.length === 0) return false;
+    const now = this.nowImpl();
+    for (const [id, g] of this.fieldGroups) if (now - g.at > 10 * 60_000 && !g.timer) this.fieldGroups.delete(id);
+    const tag = parseFieldCaption(ctx.text);
+    const group = ctx.mediaGroupId ? this.fieldGroups.get(ctx.mediaGroupId) : undefined;
+    if (!tag && !group) return false;
+    const event = tag
+      ? tag.event ?? defaultFieldEvent(
+        this.fieldDefaultEventOpt ?? this.slashContext?.userConfig?.telegram?.fieldDefaultEvent, new Date(now))
+      : group!.event;
+
+    let count: number | null = null;
+    let failure: string | null = null;
+    try {
+      const inputs = [];
+      for (const att of media) {
+        const downloaded = await this.downloadFile(att.fileId);
+        try {
+          inputs.push({
+            originalName: att.fileName ?? downloaded.fileName ?? 'media',
+            mimeType: att.mimeType ?? (att.kind === 'photo' ? 'image/jpeg' : undefined),
+            bytes: new Uint8Array(readFileSync(downloaded.localPath)),
+          });
+        } finally {
+          try { unlinkSync(downloaded.localPath); } catch { /* 이미 없음 */ }
+        }
+      }
+      // 글(자막)은 캡션이 달린 항목에만 있다 — 앨범이면 첫 장에만 붙는다(MK 2026-09-30).
+      count = saveFieldMedia(inputs, { rootDir: this.fieldRootDir(), event, device: 'telegram', ...(tag?.text ? { caption: tag.text } : {}) }).count;
+      debug.log('field.upload', 'saved', { surface: 'telegram', files: inputs.length, count, album: !!ctx.mediaGroupId });
+    } catch (err) {
+      failure = err instanceof FieldUploadError ? err.code : 'download-failed';
+      debug.log('field.upload', 'refused', { surface: 'telegram', reason: failure });
+    }
+
+    if (failure !== null) {
+      await this.sendMessage(ctx.chatId, `현장 저장 실패 · ${event} · ${failure}`, { replyTo: ctx.messageId, threadId: ctx.threadId });
+      return true;
+    }
+    const line = (n: number) => `현장 폴더에 저장 · ${event} · 지금 ${n}장`;
+    if (!ctx.mediaGroupId) {
+      await this.sendMessage(ctx.chatId, line(count!), { replyTo: ctx.messageId, threadId: ctx.threadId });
+      return true;
+    }
+    // 앨범은 항목마다 답하지 않는다 — 마지막 항목 뒤 한 번(디바운스)만 최신 수로 답한다.
+    const entry = group ?? { event, at: now, chatId: ctx.chatId, threadId: ctx.threadId, replyTo: ctx.messageId, count: 0 };
+    entry.at = now;
+    entry.count = count!;
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => {
+      entry.timer = undefined;
+      void this.sendMessage(entry.chatId, line(entry.count), { replyTo: entry.replyTo, threadId: entry.threadId })
+        .catch((e) => this.log(`field reply failed: ${e instanceof Error ? e.message : String(e)}`));
+    }, 1500);
+    (entry.timer as { unref?: () => void }).unref?.();
+    this.fieldGroups.set(ctx.mediaGroupId, entry);
+    return true;
+  }
+
   private async handleIncoming(ctx: TgIncoming): Promise<void> {
     if (!this.isOwnerAllowed(ctx.userId)) {
       await this.refuseMessage(ctx);
       return;
     }
+    // 현장 업로드 — `#현장` 캡션(또는 태그된 앨범의 나머지)의 사진·영상은 LLM 대신 현장 폴더로.
+    if (await this.tryHandleFieldUpload(ctx)) return;
+    // 영상은 `#현장` 저장 전용으로만 파싱한다 — 그 밖의 영상은 종전처럼 무시한다.
+    if (ctx.video && ctx.attachments.length === 0) return;
     // Cascade-zyu U2 — capture utterance intent at update ingress.
     try {
       const { userIntentLogger } = await import('./user-intent/index.js');
@@ -2069,6 +2159,7 @@ export class TelegramBot {
 interface PhotoSize { file_id: string; file_size?: number; width: number; height: number }
 interface VoiceLike { file_id: string; file_size?: number; mime_type?: string; duration?: number }
 interface DocumentLike { file_id: string; file_size?: number; mime_type?: string; file_name?: string }
+interface VideoLike { file_id: string; file_size?: number; mime_type?: string; file_name?: string; duration?: number }
 
 interface RawUpdate {
   update_id: number;
@@ -2083,6 +2174,8 @@ interface RawUpdate {
     voice?: VoiceLike;
     audio?: VoiceLike;
     document?: DocumentLike;
+    video?: VideoLike;
+    media_group_id?: string;
     reply_to_message?: { text?: string; message_id?: number };
   };
   callback_query?: {
@@ -2175,8 +2268,20 @@ export function parseUpdate(u: RawUpdate): TgIncoming | null {
     });
   }
 
+  // 영상은 `#현장` 저장 전용 — 태그된 캡션이거나 앨범 항목일 때만 싣는다(그 밖의 영상은 종전처럼 무시).
+  const video = m.video && (parseFieldCaption(m.caption) || m.media_group_id)
+    ? {
+        kind: 'document' as const,
+        fileId: m.video.file_id,
+        fileSize: m.video.file_size,
+        mimeType: m.video.mime_type ?? 'video/mp4',
+        fileName: m.video.file_name,
+        duration: m.video.duration,
+      }
+    : undefined;
+
   // Skip updates with zero signal: no text AND no attachments.
-  if (typeof m.text !== 'string' && attachments.length === 0) return null;
+  if (typeof m.text !== 'string' && attachments.length === 0 && !video) return null;
 
   const isDm = m.chat.type === 'private';
   return {
@@ -2191,6 +2296,8 @@ export function parseUpdate(u: RawUpdate): TgIncoming | null {
     isGroup: !isDm,
     attachments,
     ...(m.reply_to_message?.text ? { replyToText: m.reply_to_message.text } : {}),
+    ...(m.media_group_id ? { mediaGroupId: m.media_group_id } : {}),
+    ...(video ? { video } : {}),
   };
 }
 

package/src/tui-client/acp-transport-ws-client.ts

@@ -25,6 +25,7 @@ import {
   AcpTransportError,
   type AcpTransportConnection,
 } from '../acp/transport/index.js';
+import { debug } from '../debug/log.js';
 
 export interface ConnectWebSocketClientOpts {
   /** Full WebSocket URL — e.g. `ws://mbp.tailnet:31415/v1/acp`. */
@@ -42,11 +43,15 @@ export interface ConnectWebSocketClientOpts {
    *  ⛔ 없으면 서버가 핸드셰이크에 답하지 않을 때 이 Promise 가 «영원히» 안 풀린다 —
    *     그러면 호출자는 산출도 종료 코드도 못 얻는다(2026-08-31 실측: 100초 상한을 걸 때까지 매달렸다). */
   connectTimeoutMs?: number;
+  onDisconnect?(info: { reason: 'close' | 'error'; code?: number; afterMs: number; at: string; lastEventId?: string }): void;
 }
 
 /** ⏱️ 기본 연결 상한. 테일넷 왕복은 보통 수백 ms 라 넉넉하다. */
 export const DEFAULT_WS_CONNECT_TIMEOUT_MS = 10_000;
 
+/** Maximum NDJSON line inspected for an event id; ACP stream delivery is not limited. */
+const MAX_EVENT_ID_LINE_LENGTH = 64 * 1024;
+
 /** Connect to a Elanous daemon over its public WebSocket endpoint.
  *  Resolves with the bidirectional stream pair once the (optional)
  *  auth handshake has completed; rejects with `AcpTransportError` on
@@ -72,6 +77,65 @@ export async function connectWebSocketClient(
     ws.binaryType = 'arraybuffer';
 
     let settled = false;
+    let connectedAt: number | null = null;
+    let disconnected = false;
+    let lastEventId: string | undefined;
+    let incomingLine = '';
+    let oversizedLine = false;
+    const lineDecoder = new TextDecoder();
+    const recordEventId = (line: string): void => {
+      try {
+        const message: unknown = JSON.parse(line);
+        if (message !== null && typeof message === 'object' && 'id' in message
+          && typeof message.id === 'string') lastEventId = message.id;
+      } catch { /* Non-JSON or incomplete ACP payload. */ }
+    };
+    const trackEventIds = (text: string): void => {
+      let start = 0;
+      while (start < text.length) {
+        const newline = text.indexOf('\n', start);
+        const end = newline < 0 ? text.length : newline;
+        const length = end - start;
+        if (!oversizedLine) {
+          if (incomingLine.length + length <= MAX_EVENT_ID_LINE_LENGTH) {
+            incomingLine += text.slice(start, end);
+          } else {
+            incomingLine = '';
+            oversizedLine = true;
+          }
+        }
+        if (newline < 0) break;
+        if (!oversizedLine) recordEventId(incomingLine);
+        incomingLine = '';
+        oversizedLine = false;
+        start = newline + 1;
+      }
+    };
+    const recordConnected = (): void => {
+      connectedAt = Date.now();
+      try {
+        const host = new URL(opts.url).hostname;
+        debug.log('tui-client.ws', 'connected', {
+          hostKind: host === 'localhost' || host === '127.0.0.1' || host === '::1' ? 'local' : 'remote',
+        });
+      } catch { /* observation must not prevent connection */ }
+    };
+    const disconnect = (reason: 'close' | 'error', code?: number): void => {
+      finishReadable();
+      if (connectedAt === null || disconnected) return;
+      disconnected = true;
+      trackEventIds(lineDecoder.decode());
+      if (incomingLine && !oversizedLine) recordEventId(incomingLine);
+      const info = {
+        reason,
+        ...(code !== undefined ? { code } : {}),
+        afterMs: Math.max(0, Date.now() - connectedAt),
+        at: new Date().toISOString(),
+        ...(lastEventId !== undefined ? { lastEventId } : {}),
+      };
+      try { debug.log('tui-client.ws', 'disconnect', info); } catch { /* observation must not prevent notification */ }
+      opts.onDisconnect?.(info);
+    };
     let authed = !opts.token; // noAuth mode = no handshake needed
     // ⛔ 「안 됐다」를 한 값으로 접지 않는다 — «어느 단계»에서 멎었는지 이름을 붙인다.
     //    소켓조차 안 열린 것과, 열렸는데 서버가 인증에 «답을 안 한» 것은 다른 결함이다.
@@ -152,6 +216,7 @@ export async function connectWebSocketClient(
         settled = true;
         clearConnectTimer();
         opts.signal?.removeEventListener('abort', onAbort);
+        recordConnected();
         resolve(buildConnection());
         return;
       }
@@ -183,6 +248,7 @@ export async function connectWebSocketClient(
             settled = true;
             clearConnectTimer();
             opts.signal?.removeEventListener('abort', onAbort);
+            recordConnected();
             resolve(buildConnection());
           }
         } else {
@@ -191,10 +257,11 @@ export async function connectWebSocketClient(
         return;
       }
       // Authed: forward bytes to the consumer's ReadableStream.
-      if (!readableController) return;
       const bytes = typeof ev.data === 'string'
         ? new TextEncoder().encode(ev.data)
         : new Uint8Array(ev.data as ArrayBuffer);
+      trackEventIds(lineDecoder.decode(bytes, { stream: true }));
+      if (!readableController) return;
       try { readableController.enqueue(bytes); }
       catch { /* stream already closed */ }
     });
@@ -221,7 +288,7 @@ export async function connectWebSocketClient(
     ws.addEventListener('error', () => {
       // Bun/browser WebSocket fires error then close; only treat the
       // pre-settled error as a connect failure. Post-settled errors
-      // close the readable stream — the consumer surfaces it.
+      // close the readable stream and notify the dashboard once.
       if (!settled) {
         // ⛔ 「연결 오류」 한 값으로 접지 않는다 — open «전»이면 소켓이 안 열린 것이고,
         //    open «뒤»면 서버가 붙여 놓고 인증에 답하지 않은 것이다. 다른 결함이다.
@@ -229,17 +296,17 @@ export async function connectWebSocketClient(
           ? `socket never opened: connection error (${opts.url})`
           : `server accepted the socket but never answered the auth handshake: connection error (${opts.url})`);
       } else {
-        finishReadable();
+        disconnect('error');
       }
     });
 
-    ws.addEventListener('close', () => {
+    ws.addEventListener('close', (ev: CloseEvent) => {
       if (!settled) {
         failConnect(stage === 'opening'
           ? `socket never opened: closed before ready (${opts.url})`
           : `server accepted the socket but never answered the auth handshake: closed before ready (${opts.url})`);
       } else {
-        finishReadable();
+        disconnect('close', ev.code);
       }
     });
   });

package/src/tui.ts

@@ -326,7 +326,8 @@ function parseKey(data: string | Buffer): Key {
   if (s === '\x1b[3~') return K('delete');
 
   // Special keys
-  if (s === '\r' || s === '\n')   return K('enter');
+  if (s === '\r')                 return K('enter');
+  if (s === '\n')                 return K('j', true); // Ctrl+J → LF
   if (s === ' ')                  return K('space');
   if (s === '\x1b')               return K('escape');
   if (s === '\t')                 return K('tab');
@@ -341,7 +342,7 @@ function parseKey(data: string | Buffer): Key {
   // fallback for plain terminals. Ctrl+1 has no distinct wire form;
   // Ctrl+3 collides with Escape — so those must come via modKeys.
   if (s === '\x00')  return K('2', true); // Ctrl+2 → NUL
-  if (s === '\x1c')  return K('4', true); // Ctrl+4 → FS
+  if (s === '\x1c')  return K('\\', true); // Ctrl+\\ → FS; Ctrl+4 shares this byte, so requires kitty/modifyOtherKeys
   if (s === '\x1d')  return K('5', true); // Ctrl+5 → GS
   if (s.length === 1 && s.charCodeAt(0) < 32) {
     return K(String.fromCharCode(s.charCodeAt(0) + 96), true);

package/src/user-config.ts

@@ -784,6 +784,12 @@ export interface TelegramChannel {
 }
 
 /** 저장된 telegram.channels[] 파싱. 각 항목은 botToken+chatId 필수. fail-soft. */
+function normalizeKindRoles(raw: unknown): Record<string, string> | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const out = Object.fromEntries(Object.entries(raw as Record<string, unknown>).filter((e): e is [string, string] => typeof e[1] === 'string' && e[1].length > 0));
+  return Object.keys(out).length ? out : undefined;
+}
+
 function normalizeTelegramChannels(raw: unknown): TelegramChannel[] | undefined {
   if (!Array.isArray(raw)) return undefined;
   const out: TelegramChannel[] = [];
@@ -824,6 +830,11 @@ export interface TelegramConfig {
   /** 누가 Q&A 폴링을 하나 — 기본(없음·`'nexus'`)은 넥서스 데몬, `'standalone'` 이면
    *  넥서스는 폴링하지 않고 `elanous telegram run` 이 맡는다. */
   poller?: 'nexus' | 'standalone';
+  /** 발송 목적(kind) → 채널 역할. 명시 `channels` 가 있을 때만 쓴다 — 표에 없는 kind 는 옛 `reportChannel` 로 간다.
+   *  기본표는 `DEFAULT_KIND_ROLES`(telegram-report.ts) · 여기 값이 덮어쓴다. */
+  kindRoles?: Record<string, string>;
+  /** `#현장` 캡션에 행사 슬러그가 없을 때 쓸 기본 행사(예: `marketers-night-2026-10`). 없으면 `field-<로컬 날짜>`. */
+  fieldDefaultEvent?: string;
 }
 
 const TELEGRAM_DEFAULTS: TelegramConfig = { enabled: false, allowedUsers: [] };
@@ -3315,12 +3326,12 @@ export function resolveRoleModel(role: ModelRole, config: UserConfig = getUserCo
 
 export interface UserConfig {
   /** Steward loop: observe-only until an independently approved act implementation exists. */
-  loops?: { steward?: { mode?: 'observe' | 'act'; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number } };
+  loops?: { steward?: { mode?: 'observe' | 'act'; linearTeam?: string; roles?: Record<string, { maxConcurrent?: number }>; budget?: number; tracks?: Record<string, string> } };
   /** 🔐 Pod 의 Grok API 키 과금은 명시 opt-in 만. 생략·잘못된 값은 false.
    *  budgetGate 와 같은 `harness` 객체다 — 중복 선언이면 뒤 타입이 앞을 지운다. */
   harness?: { pod?: { grokApiKeyOptIn: boolean }; budgetGate?: HarnessBudgetGateConfig; defaultRepo?: string; substrate?: 'local' | 'pod'; podPool?: string };
   /** ☸️ Pod 실행 칸 — `pool` = 기존 기본 풀(`컨텍스트[@ssh호스트][:상한]` 쉼표 · 앞이 우선). harness 실행은 인자·ELANOUS_POD_POOL·harness.podPool 다음으로 읽는다. */
-  pod?: { pool?: string; /** 원격 그라운딩 엔드포인트(호스트 nexus · tailnet 주소) — Pod 가 토큰으로 «질의→인용»만 묻는다(P13). */ groundingUrl?: string };
+  pod?: { pool?: string; /** 호스트 Git 미러 디렉터리 — Pod Job 에 읽기 전용으로 마운트한다. */ hostMirror?: string; /** 원격 그라운딩 엔드포인트(호스트 nexus · tailnet 주소) — Pod 가 토큰으로 «질의→인용»만 묻는다(P13). */ groundingUrl?: string };
   skillRouter: SkillRouterConfig;
   llm: LLMConfig;
   skills: SkillsConfig;
@@ -4106,6 +4117,15 @@ function observeRetiredConfigKeysOnce(raw: Record<string, unknown>): void {
   } catch { /* observation must never break config loading */ }
 }
 
+/** Owner tracks the steward may assign (key → what that track owns). The one place the role table lives. */
+function parseStewardTracks(input: unknown): Record<string, string> | undefined {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return undefined;
+  const out = Object.fromEntries(Object.entries(input as Record<string, unknown>)
+    .filter((e): e is [string, string] => /^[A-Za-z][\w-]{0,15}$/.test(e[0]) && typeof e[1] === 'string' && e[1].trim().length > 0)
+    .map(([k, v]) => [k, v.trim()]));
+  return Object.keys(out).length ? out : undefined;
+}
+
 function parseStewardLoopsConfig(input: unknown): UserConfig['loops'] {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return undefined;
   const value = (input as Record<string, unknown>).steward;
@@ -4124,6 +4144,7 @@ function parseStewardLoopsConfig(input: unknown): UserConfig['loops'] {
     ...(typeof s.linearTeam === 'string' && s.linearTeam.trim() ? { linearTeam: s.linearTeam.trim() } : {}),
     ...(Object.keys(roles).length ? { roles } : {}),
     ...(typeof s.budget === 'number' && Number.isFinite(s.budget) && s.budget >= 0 ? { budget: s.budget } : {}),
+    ...(parseStewardTracks(s.tracks) ? { tracks: parseStewardTracks(s.tracks)! } : {}),
   } };
 }
 
@@ -4233,6 +4254,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
   return {
     pod: {
       ...(typeof legacyPod.pool === 'string' && legacyPod.pool.trim() ? { pool: legacyPod.pool.trim() } : {}),
+      ...(typeof legacyPod.hostMirror === 'string' && legacyPod.hostMirror.trim() ? { hostMirror: legacyPod.hostMirror.trim() } : {}),
       ...(typeof legacyPod.groundingUrl === 'string' ? { groundingUrl: legacyPod.groundingUrl } : {}),
     },
     harness: {
@@ -4372,6 +4394,8 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       channels: normalizeTelegramChannels(tg.channels),
       testChannel: normalizeTestChannel(tg.testChannel),
       ...(tg.poller === 'standalone' || tg.poller === 'nexus' ? { poller: tg.poller } : {}),
+      ...(normalizeKindRoles(tg.kindRoles) ? { kindRoles: normalizeKindRoles(tg.kindRoles)! } : {}),
+      ...(str(tg.fieldDefaultEvent) ? { fieldDefaultEvent: str(tg.fieldDefaultEvent)! } : {}),
     },
     discord: {
       enabled: dc.enabled === true,
@@ -5426,6 +5450,11 @@ export function saveUserConfig(
   const rawHarness = rawRest.harness && typeof rawRest.harness === 'object' && !Array.isArray(rawRest.harness)
     ? rawRest.harness as Record<string, unknown> : {};
   delete rawRest.harness;
+  if (cfg.pod?.hostMirror) {
+    const rawPod = rawRest.pod && typeof rawRest.pod === 'object' && !Array.isArray(rawRest.pod)
+      ? rawRest.pod as Record<string, unknown> : {};
+    rawRest.pod = { ...rawPod, hostMirror: cfg.pod.hostMirror };
+  }
 
   const out: Record<string, unknown> = {
     harness: stripUndef({
@@ -5539,6 +5568,7 @@ export function saveUserConfig(
       // ★ 2026-09-25: `poller`(T1 분리 스위치)가 파서엔 있고 이 whitelist 에 없어 `config set telegram.poller` 가
       //   「직렬화 드롭」으로 조용히 사라졌다 — 운영 전환 스위치를 켤 방법이 없었다(07-22 botUsername 과 같은 모양).
       poller: cfg.telegram.poller,
+      fieldDefaultEvent: cfg.telegram.fieldDefaultEvent,
     }),
     discord: stripUndef({
       enabled: cfg.discord.enabled,

package/src/util/spawn-sync-output.ts

@@ -0,0 +1,15 @@
+import { spawnSync, type SpawnSyncOptionsWithStringEncoding } from 'node:child_process';
+
+/** Read command text completely or fail closed; never return a partial stdout. */
+export function spawnSyncText(
+  cmd: string,
+  args: readonly string[],
+  opts: SpawnSyncOptionsWithStringEncoding = { encoding: 'utf8' },
+): string {
+  const result = spawnSync(cmd, [...args], { ...opts, maxBuffer: opts.maxBuffer ?? 256 * 1024 * 1024 });
+  if (result.error || result.status !== 0) {
+    const reason = result.error?.message ?? result.stderr?.trim() ?? '';
+    throw new Error(`${cmd} ${args.join(' ')} failed (status=${result.status}${result.error ? `, error=${(result.error as NodeJS.ErrnoException).code ?? result.error.name}` : ''}): ${reason}`);
+  }
+  return result.stdout;
+}

package/src/version/code-revision.ts

@@ -54,7 +54,7 @@ function usableInstallMetadataCommit(commit: string): string | undefined {
   return revision;
 }
 
-function readInstallMetadataCommit(metadataPath: string): string | undefined {
+export function readInstallMetadataCommit(metadataPath: string): string | undefined {
   try {
     const parsed: unknown = JSON.parse(readFileSync(metadataPath, 'utf8'));
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"0b373c740eb18bdeefe8a8e0710d756b3f36d658"}
+{"commit":"65a4c7230c60a536b0f0f0428322c8ddcbcac752"}