@kenkaiiii/gg-boss 4.3.154 → 4.3.156

package/dist/cli.js

@@ -9,6 +9,7 @@ import {
   CompactionSpinner,
   GGBoss,
   InputArea,
+  MODELS,
   MessageResponse,
   ModelSelector,
   SelectList,
@@ -21,7 +22,9 @@ import {
   ToolUseLoader,
   UserMessage,
   bossStore,
+  closeLogger,
   getAppPaths,
+  getBossState,
   getContextWindow,
   getSplashAudioDurationMs,
   initLogger,
@@ -32,6 +35,8 @@ import {
   render_default,
   require_jsx_runtime,
   require_react,
+  saveSettings,
+  subscribeToBossStore,
   tasksStore,
   useAnimationActive,
   useAnimationTick,
@@ -43,7 +48,7 @@ import {
   use_app_default,
   use_input_default,
   use_stdout_default
-} from "./chunk-WGJRDNT6.js";
+} from "./chunk-KWWLOD25.js";
 import "./chunk-QT366Y52.js";
 import {
   source_default
@@ -55,7 +60,7 @@ import {
 
 // src/cli.ts
 init_esm_shims();
-import path4 from "path";
+import path5 from "path";
 
 // src/links.ts
 init_esm_shims();
@@ -336,7 +341,7 @@ init_esm_shims();
 // package.json
 var package_default = {
   name: "@kenkaiiii/gg-boss",
-  version: "4.3.154",
+  version: "4.3.156",
   type: "module",
   description: "Orchestrator agent that drives multiple ggcoder sessions across projects from a single chat",
   license: "MIT",
@@ -376,6 +381,10 @@ var package_default = {
     vitest: "^4.1.4",
     zod: "^4.4.3"
   },
+  optionalDependencies: {
+    "@huggingface/transformers": "^3.6.0",
+    "ogg-opus-decoder": "^1.6.13"
+  },
   publishConfig: {
     access: "public"
   }
@@ -632,7 +641,7 @@ async function runLinkCommand() {
     process.stdout.write(source_default.hex(COLORS.textDim)("\nCancelled. No changes saved.\n"));
     return;
   }
-  const linked = result.selected.map((path5) => projects.find((p) => p.path === path5)).filter((p) => Boolean(p)).map((p) => ({ name: p.name, cwd: p.path }));
+  const linked = result.selected.map((path6) => projects.find((p) => p.path === path6)).filter((p) => Boolean(p)).map((p) => ({ name: p.name, cwd: p.path }));
   await saveLinks({ projects: linked });
   process.stdout.write("\n");
   if (linked.length === 0) {
@@ -657,6 +666,872 @@ async function runLinkCommand() {
   }
 }
 
+// src/serve-mode.ts
+init_esm_shims();
+import path3 from "path";
+import fs3 from "fs/promises";
+
+// src/voice-transcriber.ts
+init_esm_shims();
+var TARGET_SAMPLE_RATE = 16e3;
+var MODEL_ID = "Xenova/whisper-tiny.en";
+var transcriber = null;
+var loadPromise = null;
+var onProgress = null;
+function setProgressCallback(cb) {
+  onProgress = cb;
+}
+function resample(audio, fromRate, toRate) {
+  if (fromRate === toRate) return audio;
+  const ratio = fromRate / toRate;
+  const newLength = Math.round(audio.length / ratio);
+  const result = new Float32Array(newLength);
+  for (let i = 0; i < newLength; i++) {
+    const srcIndex = i * ratio;
+    const low = Math.floor(srcIndex);
+    const high = Math.min(low + 1, audio.length - 1);
+    const frac = srcIndex - low;
+    result[i] = audio[low] * (1 - frac) + audio[high] * frac;
+  }
+  return result;
+}
+function downmixToMono(channelData) {
+  if (channelData.length === 0) return new Float32Array();
+  if (channelData.length === 1) return channelData[0];
+  const samples = channelData[0].length;
+  const out = new Float32Array(samples);
+  const scale = 1 / channelData.length;
+  for (let i = 0; i < samples; i++) {
+    let mixed = 0;
+    for (const channel of channelData) mixed += channel[i] ?? 0;
+    out[i] = mixed * scale;
+  }
+  return out;
+}
+async function decodeOggOpus(buffer) {
+  const { OggOpusDecoder } = await import("ogg-opus-decoder");
+  const decoder = new OggOpusDecoder();
+  await decoder.ready;
+  try {
+    const decoded = await decoder.decodeFile(buffer);
+    if (!decoded.channelData?.length || !decoded.channelData[0]?.length) {
+      throw new Error("Decoded audio is empty");
+    }
+    const mono = downmixToMono(decoded.channelData);
+    return resample(mono, decoded.sampleRate, TARGET_SAMPLE_RATE);
+  } finally {
+    decoder.free();
+  }
+}
+async function getTranscriber() {
+  if (transcriber) return transcriber;
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      const { pipeline } = await import("@huggingface/transformers");
+      const instance = await pipeline("automatic-speech-recognition", MODEL_ID, {
+        dtype: "fp32",
+        progress_callback: onProgress ?? void 0
+      });
+      transcriber = instance;
+      return instance;
+    })();
+  }
+  return loadPromise;
+}
+function isModelLoaded() {
+  return transcriber !== null;
+}
+async function transcribeVoice(fileUrl) {
+  const response = await fetch(fileUrl);
+  if (!response.ok) throw new Error(`Failed to download voice file: ${response.status}`);
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  const pcm = await decodeOggOpus(buffer);
+  const asr = await getTranscriber();
+  const result = await asr(pcm);
+  const text = Array.isArray(result) ? result[0]?.text : result.text;
+  return (text ?? "").trim();
+}
+
+// src/telegram.ts
+init_esm_shims();
+var TELEGRAM_API = "https://api.telegram.org";
+var MAX_MESSAGE_LENGTH = 4096;
+var TelegramBot = class {
+  token;
+  allowedUserId;
+  offset = 0;
+  running = false;
+  onMessage = null;
+  onVoiceMessage = null;
+  onCallback = null;
+  onBotAdded = null;
+  onBotRemoved = null;
+  constructor(config) {
+    this.token = config.botToken;
+    this.allowedUserId = config.allowedUserId;
+  }
+  /** Register handler for incoming text messages. */
+  onText(handler) {
+    this.onMessage = handler;
+  }
+  /** Register handler for incoming voice notes. */
+  onVoice(handler) {
+    this.onVoiceMessage = handler;
+  }
+  /** Register handler for inline keyboard button presses. */
+  onCallbackQuery(handler) {
+    this.onCallback = handler;
+  }
+  /** Register handler for when the bot is added to a group. */
+  onAddedToGroup(handler) {
+    this.onBotAdded = handler;
+  }
+  /** Register handler for when the bot is removed from a group. */
+  onRemovedFromGroup(handler) {
+    this.onBotRemoved = handler;
+  }
+  /** Start long polling. Blocks until stop() is called. */
+  async start() {
+    this.running = true;
+    const me = await this.apiCall("getMe");
+    if (!me.ok) {
+      throw new Error(`Invalid bot token: ${JSON.stringify(me)}`);
+    }
+    while (this.running) {
+      try {
+        const updates = await this.getUpdates();
+        for (const update of updates) {
+          await this.handleUpdate(update);
+        }
+      } catch (err) {
+        if (!this.running) break;
+        console.error(`[telegram] Poll error: ${err instanceof Error ? err.message : err}`);
+        await sleep(3e3);
+      }
+    }
+  }
+  /** Stop long polling. */
+  stop() {
+    this.running = false;
+  }
+  /** Send a text message to a specific chat. Converts markdown and splits long messages. */
+  async send(chatId, text, buttons) {
+    const converted = toTelegramMarkdown(text);
+    const chunks = splitMessage(converted);
+    for (let i = 0; i < chunks.length; i++) {
+      const isLast = i === chunks.length - 1;
+      const replyMarkup = isLast && buttons ? {
+        inline_keyboard: buttons.map(
+          (row) => row.map((b) => ({ text: b.text, callback_data: b.callback_data }))
+        )
+      } : void 0;
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunks[i],
+        parse_mode: "Markdown",
+        ...replyMarkup ? { reply_markup: replyMarkup } : {}
+      });
+    }
+  }
+  /** Send a plain text message (no markdown parsing) to a specific chat. */
+  async sendPlain(chatId, text) {
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) {
+      await this.apiCall("sendMessage", {
+        chat_id: chatId,
+        text: chunk
+      });
+    }
+  }
+  /** Send a typing indicator to a specific chat. */
+  async sendTyping(chatId) {
+    await this.apiCall("sendChatAction", {
+      chat_id: chatId,
+      action: "typing"
+    });
+  }
+  /** Get a direct download URL for a Telegram file. */
+  async getFileUrl(fileId) {
+    const result = await this.apiCall("getFile", { file_id: fileId });
+    if (!result.ok) throw new Error(`Failed to get file: ${JSON.stringify(result)}`);
+    const filePath = result.result.file_path;
+    return `${TELEGRAM_API}/file/bot${this.token}/${filePath}`;
+  }
+  // ── Private ───────────────────────────────────────────
+  async getUpdates() {
+    const result = await this.apiCall("getUpdates", {
+      offset: this.offset,
+      timeout: 30,
+      allowed_updates: ["message", "callback_query", "my_chat_member"]
+    });
+    if (!result.ok || !Array.isArray(result.result)) return [];
+    const updates = result.result;
+    if (updates.length > 0) {
+      this.offset = updates[updates.length - 1].update_id + 1;
+    }
+    return updates;
+  }
+  async handleUpdate(update) {
+    if (update.message) {
+      const msg = update.message;
+      if (msg.from.id !== this.allowedUserId) {
+        return;
+      }
+      if (msg.text && this.onMessage) {
+        this.onMessage({
+          text: msg.text,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      } else if (msg.voice && this.onVoiceMessage) {
+        this.onVoiceMessage({
+          fileId: msg.voice.file_id,
+          duration: msg.voice.duration,
+          chatId: msg.chat.id,
+          chatType: msg.chat.type,
+          chatTitle: msg.chat.title
+        });
+      }
+    }
+    if (update.my_chat_member) {
+      const member = update.my_chat_member;
+      const status = member.new_chat_member.status;
+      if ((status === "member" || status === "administrator") && this.onBotAdded) {
+        this.onBotAdded(member.chat.id, member.chat.title);
+      } else if ((status === "left" || status === "kicked") && this.onBotRemoved) {
+        this.onBotRemoved(member.chat.id);
+      }
+    }
+    if (update.callback_query) {
+      const cb = update.callback_query;
+      if (cb.from.id !== this.allowedUserId) return;
+      await this.apiCall("answerCallbackQuery", { callback_query_id: cb.id });
+      if (cb.data && this.onCallback) {
+        this.onCallback(cb.data, cb.message.chat.id);
+      }
+    }
+  }
+  async apiCall(method, body) {
+    const url = `${TELEGRAM_API}/bot${this.token}/${method}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      return { ok: false };
+    }
+    return response.json();
+  }
+};
+function toTelegramMarkdown(text) {
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trimStart().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    let transformed = line;
+    const headingMatch = transformed.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      transformed = `*${headingMatch[2]}*`;
+      result.push(transformed);
+      continue;
+    }
+    if (/^(-{3,}|_{3,}|\*{3,})$/.test(transformed.trim())) {
+      result.push("");
+      continue;
+    }
+    transformed = transformed.replace(/\*\*(.+?)\*\*/g, "*$1*");
+    result.push(transformed);
+  }
+  return result.join("\n");
+}
+function splitMessage(text) {
+  if (text.length <= MAX_MESSAGE_LENGTH) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= MAX_MESSAGE_LENGTH) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+    }
+    if (splitAt === -1 || splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+      splitAt = MAX_MESSAGE_LENGTH;
+    }
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/serve-mode.ts
+function getTelegramConfigPath() {
+  return path3.join(getAppPaths().agentDir, "boss", "telegram.json");
+}
+async function loadBossTelegramConfig() {
+  try {
+    const raw = await fs3.readFile(getTelegramConfigPath(), "utf-8");
+    const data = JSON.parse(raw);
+    if (data.botToken && data.userId) return data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveBossTelegramConfig(config) {
+  const file = getTelegramConfigPath();
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+}
+function formatItemForTelegram(item) {
+  switch (item.kind) {
+    case "user":
+    case "tool":
+    case "worker_event":
+      return null;
+    case "assistant": {
+      const cleaned = stripScopePrefix(item.text).trim();
+      return cleaned ? truncate(cleaned, 1500) : null;
+    }
+    case "worker_error":
+      return `\u2717 *${item.project}* \u2014 ${truncate(item.message, 300)}`;
+    case "info":
+      if (item.level !== "warning" && item.level !== "error") return null;
+      return `${item.level === "error" ? "\u2717 " : "\u26A0 "}_${truncate(item.text, 300)}_`;
+    case "task_dispatch": {
+      if (item.tasks.length === 0) return null;
+      const projects = [...new Set(item.tasks.map((t) => t.project))];
+      if (item.tasks.length === 1) {
+        const t = item.tasks[0];
+        return `\u2192 *${t.project}*: ${truncate(t.title, 140)}`;
+      }
+      return `\u2192 Dispatched ${item.tasks.length} tasks across ${projects.length} project${projects.length === 1 ? "" : "s"}`;
+    }
+    case "update_notice":
+      return `\u2728 ${item.text}`;
+  }
+}
+function stripScopePrefix(text) {
+  return text.replace(/^\s*\[scope:[^\]]+\]\s*/, "");
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1).trimEnd() + "\u2026";
+}
+function scopePrefix(scope) {
+  if (scope === "all") return "[scope:all] ";
+  return `[scope:${scope}] `;
+}
+async function runBossServeMode(options) {
+  initLogger({
+    version: VERSION,
+    bossProvider: options.bossProvider,
+    bossModel: options.bossModel,
+    bossThinking: options.bossThinkingLevel,
+    workerProvider: options.workerProvider,
+    workerModel: options.workerModel,
+    projectCount: 0
+  });
+  const links = await loadLinks();
+  if (links.projects.length === 0) {
+    console.error(
+      source_default.hex(COLORS.error)("No linked projects.\n") + source_default.hex(COLORS.textDim)("Run ") + source_default.hex(COLORS.accent)("ggboss link") + source_default.hex(COLORS.textDim)(" first to choose which projects the boss should manage.")
+    );
+    process.exit(1);
+  }
+  const projects = links.projects.map((p) => ({ name: p.name, cwd: p.cwd }));
+  await tasksStore.load();
+  const bot = new TelegramBot({
+    botToken: options.telegram.botToken,
+    allowedUserId: options.telegram.userId
+  });
+  const boss = new GGBoss({
+    bossProvider: options.bossProvider,
+    bossModel: options.bossModel,
+    bossThinkingLevel: options.bossThinkingLevel,
+    workerProvider: options.workerProvider,
+    workerModel: options.workerModel,
+    workerThinkingLevel: options.workerThinkingLevel,
+    projects
+  });
+  await boss.initialize();
+  log("INFO", "serve", "boss initialized", { projects: projects.map((p) => p.name).join(",") });
+  const allowedChatId = options.telegram.userId;
+  const pendingScopeSelections = /* @__PURE__ */ new Map();
+  const pendingModelSelections = /* @__PURE__ */ new Map();
+  let lastHistoryLen = getBossState().history.length;
+  let typingInterval = null;
+  let isStreaming = false;
+  function sendQueued(text) {
+    bot.send(allowedChatId, text).catch((err) => {
+      log("WARN", "telegram", `send failed: ${err instanceof Error ? err.message : String(err)}`);
+      bot.sendPlain(allowedChatId, text.replace(/[*_`]/g, "")).catch(() => {
+      });
+    });
+  }
+  function startTyping() {
+    if (typingInterval) return;
+    bot.sendTyping(allowedChatId).catch(() => {
+    });
+    typingInterval = setInterval(() => {
+      bot.sendTyping(allowedChatId).catch(() => {
+      });
+    }, 4e3);
+  }
+  function stopTyping() {
+    if (typingInterval) {
+      clearInterval(typingInterval);
+      typingInterval = null;
+    }
+  }
+  function flushNewItems(state) {
+    const len = state.history.length;
+    if (len <= lastHistoryLen) return;
+    const fresh = state.history.slice(lastHistoryLen);
+    lastHistoryLen = len;
+    for (const item of fresh) {
+      const formatted = formatItemForTelegram(item);
+      if (formatted) sendQueued(formatted);
+    }
+  }
+  async function applyModelChoice(target, selected) {
+    try {
+      if (target === "boss") {
+        await boss.switchBossModel(selected.provider, selected.id);
+        await saveSettings({ bossProvider: selected.provider, bossModel: selected.id });
+        await bot.send(allowedChatId, `Boss \u2192 *${selected.name}*`);
+      } else {
+        await boss.switchWorkerModel(selected.provider, selected.id);
+        await saveSettings({ workerProvider: selected.provider, workerModel: selected.id });
+        await bot.send(allowedChatId, `Workers \u2192 *${selected.name}*`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log("WARN", "model_switch", message, { target, model: selected.id });
+      await bot.send(allowedChatId, `Failed to switch ${target}: ${message}`);
+    }
+  }
+  const unsubscribe = subscribeToBossStore(() => {
+    if (getBossState().pendingFlush.length > 0) {
+      bossStore.commitPendingFlush();
+    }
+    const state = getBossState();
+    flushNewItems(state);
+    const streamingNow = state.streaming !== null;
+    if (streamingNow && !isStreaming) {
+      isStreaming = true;
+      startTyping();
+    } else if (!streamingNow && isStreaming) {
+      isStreaming = false;
+      stopTyping();
+    }
+  });
+  bot.onText(async (msg) => {
+    const { text, chatId } = msg;
+    if (chatId !== allowedChatId) return;
+    const pendingScopes = pendingScopeSelections.get(chatId);
+    if (pendingScopes && /^\s*\d+\s*$/.test(text)) {
+      pendingScopeSelections.delete(chatId);
+      const num = parseInt(text.trim(), 10);
+      if (num < 1 || num > pendingScopes.length) {
+        await bot.send(chatId, "Invalid selection. Send /scope to try again.");
+        return;
+      }
+      const chosen = pendingScopes[num - 1];
+      bossStore.setScope(chosen);
+      await bot.send(chatId, `Scope: *${chosen}*`);
+      return;
+    }
+    const pendingModel = pendingModelSelections.get(chatId);
+    if (pendingModel && /^\s*\d+\s*$/.test(text)) {
+      pendingModelSelections.delete(chatId);
+      const num = parseInt(text.trim(), 10);
+      if (num < 1 || num > pendingModel.models.length) {
+        await bot.send(chatId, "Invalid selection. Send /m to try again.");
+        return;
+      }
+      const selected = pendingModel.models[num - 1];
+      await applyModelChoice(pendingModel.target, selected);
+      return;
+    }
+    if (!text.startsWith("/")) {
+      const scoped = scopePrefix(getBossState().scope) + text;
+      boss.enqueueUserMessage(scoped);
+      return;
+    }
+    const parts = text.trim().split(/\s+/);
+    const cmd = parts[0].slice(1).toLowerCase().replace(/@\w+$/, "");
+    if (cmd === "help" || cmd === "start") {
+      await bot.send(chatId, buildTelegramHelpText());
+      return;
+    }
+    if (cmd === "m" || cmd === "model" || cmd === "model-boss" || cmd === "model-workers") {
+      const target = cmd === "model-workers" ? "workers" : "boss";
+      const arg = parts.slice(1).join(" ").trim().toLowerCase();
+      const state = getBossState();
+      const currentId = target === "boss" ? state.bossModel : state.workerModel;
+      if (arg) {
+        const num = parseInt(arg, 10);
+        let match;
+        if (!isNaN(num) && num >= 1 && num <= MODELS.length) {
+          match = MODELS[num - 1];
+        } else {
+          match = MODELS.find(
+            (m) => m.name.toLowerCase().includes(arg) || m.id.toLowerCase().includes(arg)
+          );
+        }
+        if (!match) {
+          await bot.send(chatId, `No model matching "${arg}". Send /${cmd} to see the list.`);
+          return;
+        }
+        await applyModelChoice(target, match);
+        return;
+      }
+      let listText = `*${target === "boss" ? "Boss" : "Worker"} model*
+`;
+      let lastProvider = "";
+      MODELS.forEach((m, i) => {
+        if (m.provider !== lastProvider) {
+          lastProvider = m.provider;
+          listText += `
+_${providerLabel(m.provider)}_
+`;
+        }
+        const active = m.id === currentId ? "  \u2190" : "";
+        listText += `  *${i + 1}.* ${m.name}${active}
+`;
+      });
+      listText += `
+Send the number, or \`/${cmd} <name>\`.`;
+      pendingModelSelections.set(chatId, { target, models: [...MODELS] });
+      await bot.send(chatId, listText);
+      return;
+    }
+    if (cmd === "scope" || cmd === "s") {
+      const state = getBossState();
+      const arg = parts.slice(1).join(" ").trim().toLowerCase();
+      const names = ["all", ...state.workers.map((w) => w.name)];
+      if (!arg) {
+        const lines = names.map((n, i) => {
+          const active = n === state.scope ? "  \u2190" : "";
+          const label = n === "all" ? "*All*" : `*${n}*`;
+          return `*${i + 1}.* ${label}${active}`;
+        });
+        pendingScopeSelections.set(chatId, names);
+        await bot.send(
+          chatId,
+          `*Scope*  \u2014  current: *${state.scope}*
+
+${lines.join("\n")}
+
+Send the number, or \`/scope <name>\`.`
+        );
+        return;
+      }
+      const num = parseInt(arg, 10);
+      let chosen;
+      if (!isNaN(num) && num >= 1 && num <= names.length) {
+        chosen = names[num - 1];
+      } else {
+        const exact = names.find((n) => n.toLowerCase() === arg);
+        chosen = exact ?? names.find((n) => n.toLowerCase().includes(arg)) ?? null;
+      }
+      if (!chosen) {
+        await bot.send(chatId, `No scope matching "${arg}". Send /scope to see the list.`);
+        return;
+      }
+      bossStore.setScope(chosen);
+      await bot.send(chatId, `Scope: *${chosen}*`);
+      return;
+    }
+    if (cmd === "status") {
+      const state = getBossState();
+      const lines = [
+        `*${BRAND}* \u2014 ${state.bossModel}`,
+        `Scope  *${state.scope}*`,
+        ""
+      ];
+      lines.push("*Workers*");
+      for (const w of state.workers) {
+        const dot = w.status === "working" ? "\u25CF" : w.status === "error" ? "\u2717" : "\u25CB";
+        lines.push(`  ${dot} *${w.name}* \u2014 _${w.status}_`);
+      }
+      const tasks = tasksStore.list();
+      const open = tasks.filter((t) => t.status === "pending" || t.status === "in_progress").length;
+      lines.push("");
+      lines.push(`Tasks  ${open} open  \xB7  ${tasks.length} total`);
+      await bot.send(chatId, lines.join("\n"));
+      return;
+    }
+    if (cmd === "cancel") {
+      boss.abort();
+      await bot.send(chatId, "_Aborted current boss turn._");
+      return;
+    }
+    if (cmd === "new" || cmd === "n") {
+      await boss.newSession();
+      await bot.send(chatId, "\u2500\u2500 *New session* \u2500\u2500");
+      return;
+    }
+    if (cmd === "tasks") {
+      const tasks = tasksStore.list();
+      if (tasks.length === 0) {
+        await bot.send(chatId, "_No tasks._");
+        return;
+      }
+      const lines = tasks.slice(0, 30).map((t, i) => {
+        const status = t.status.replace("_", " ");
+        return `*${i + 1}.* [${status}] *${t.project}* \u2014 ${t.description.split("\n")[0]}`;
+      });
+      await bot.send(chatId, `*Tasks*
+
+${lines.join("\n")}`);
+      return;
+    }
+    boss.enqueueUserMessage(text);
+  });
+  bot.onVoice(async (msg) => {
+    const { chatId } = msg;
+    if (chatId !== allowedChatId) return;
+    try {
+      if (!isModelLoaded()) {
+        await bot.send(
+          chatId,
+          "Setting up voice transcription \u2014 downloading Whisper model. This only happens once."
+        );
+        setProgressCallback((info) => {
+          if (info.status === "progress" && info.progress !== void 0) {
+            const pct = Math.round(info.progress);
+            if (pct % 25 === 0 && pct > 0) {
+              bot.sendTyping(chatId).catch(() => {
+              });
+            }
+          }
+        });
+      }
+      await bot.sendTyping(chatId);
+      const fileUrl = await bot.getFileUrl(msg.fileId);
+      const transcribed = await transcribeVoice(fileUrl);
+      if (!transcribed) {
+        await bot.send(chatId, "_Could not transcribe voice note._");
+        return;
+      }
+      await bot.send(chatId, `_Voice: "${transcribed}"_`);
+      const scoped = scopePrefix(getBossState().scope) + transcribed;
+      boss.enqueueUserMessage(scoped);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log("ERROR", "voice", message);
+      const hint = /Cannot find module|Cannot resolve|MODULE_NOT_FOUND/.test(message) ? "\n\nVoice transcription needs the optional `@huggingface/transformers` and `ogg-opus-decoder` packages. Reinstall with `npm i -g @kenkaiiii/gg-boss` and ensure optional deps installed." : "";
+      await bot.send(chatId, `_Voice transcription failed: ${message}_${hint}`);
+    }
+  });
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+  printBanner({
+    bossModel: options.bossModel,
+    workerModel: options.workerModel,
+    userId: options.telegram.userId,
+    projectCount: projects.length
+  });
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(source_default.hex(COLORS.textDim)("\nShutting down..."));
+    bot.stop();
+    stopTyping();
+    unsubscribe();
+    await boss.dispose().catch(() => {
+    });
+    closeLogger();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+  const runPromise = boss.run().catch((err) => {
+    log("ERROR", "boss", err instanceof Error ? err.message : String(err));
+  });
+  await bot.start();
+  await runPromise;
+}
+function buildTelegramHelpText() {
+  return [
+    "*GG Boss* \u2014 orchestrator over Telegram",
+    "",
+    "*Commands*",
+    "/scope (/s) \u2014 switch project focus (All / per-worker)",
+    "/m, /model-boss \u2014 switch the orchestrator's model",
+    "/model-workers \u2014 switch every worker's model",
+    "/status \u2014 workers + open tasks",
+    "/tasks \u2014 list tasks",
+    "/new \u2014 fresh boss session",
+    "/cancel \u2014 abort the current boss turn",
+    "/help \u2014 this message",
+    "",
+    "Voice notes are transcribed locally with Whisper and sent as prompts.",
+    "Send any message to talk to the boss."
+  ].join("\n");
+}
+function providerLabel(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "Anthropic";
+    case "openai":
+      return "OpenAI";
+    case "glm":
+      return "Z.AI";
+    case "moonshot":
+      return "Moonshot";
+    case "minimax":
+      return "MiniMax";
+    case "deepseek":
+      return "DeepSeek";
+    case "openrouter":
+      return "OpenRouter";
+    case "xiaomi":
+      return "Xiaomi";
+    default:
+      return provider;
+  }
+}
+function gradientText(text) {
+  let i = 0;
+  return text.split("").map((ch) => ch === " " ? ch : source_default.hex(GRADIENT[i++ % GRADIENT.length])(ch)).join("");
+}
+function printBanner(opts) {
+  console.log();
+  console.log(
+    `  ${gradientText(LOGO_LINES[0])}${LOGO_GAP}` + source_default.hex(COLORS.primary).bold(BRAND) + source_default.hex(COLORS.textDim)(` v${VERSION}`) + source_default.hex(COLORS.textDim)(" \xB7 By ") + source_default.white.bold(AUTHOR)
+  );
+  console.log(
+    `  ${gradientText(LOGO_LINES[1])}${LOGO_GAP}` + source_default.hex(COLORS.accent)(`Boss: ${opts.bossModel}`)
+  );
+  console.log(
+    `  ${gradientText(LOGO_LINES[2])}${LOGO_GAP}` + source_default.hex(COLORS.textDim)(`Workers: ${opts.workerModel}`)
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.textDim)("  Mode      ") + source_default.hex(COLORS.accent)("Telegram") + source_default.hex(COLORS.textDim)("  \xB7  User ") + source_default.white(String(opts.userId)) + source_default.hex(COLORS.textDim)(
+      `  \xB7  ${opts.projectCount} project${opts.projectCount === 1 ? "" : "s"}`
+    )
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.success)("  Ready. ") + source_default.hex(COLORS.textDim)("Open Telegram and message your bot.")
+  );
+  console.log();
+  console.log(
+    source_default.hex(COLORS.textDim)("  /help  ") + source_default.hex(COLORS.textDim)("commands") + source_default.hex(COLORS.textDim)("    /status  ") + source_default.hex(COLORS.textDim)("workers + tasks") + source_default.hex(COLORS.textDim)("    /cancel  ") + source_default.hex(COLORS.textDim)("abort turn")
+  );
+  console.log();
+}
+
+// src/telegram-setup.ts
+init_esm_shims();
+import readline2 from "readline/promises";
+async function runBossTelegramSetup() {
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+  printSetupBanner();
+  const existing = await loadBossTelegramConfig();
+  if (existing) {
+    console.log(
+      source_default.hex(COLORS.textDim)("  Current config:\n") + source_default.hex(COLORS.textDim)(
+        `    Bot token: ${existing.botToken.slice(0, 10)}...${existing.botToken.slice(-4)}
+`
+      ) + source_default.hex(COLORS.textDim)(`    User ID:   ${existing.userId}
+`)
+    );
+  }
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    console.log(
+      source_default.hex(COLORS.accent)("  Step 1: Bot Token\n") + source_default.hex(COLORS.textDim)("    1. Open BotFather: ") + source_default.hex(COLORS.primary).underline("https://t.me/BotFather") + "\n" + source_default.hex(COLORS.textDim)("    2. Send /newbot and follow the prompts\n") + source_default.hex(COLORS.textDim)("    3. Copy the bot token\n")
+    );
+    const tokenPrompt = existing ? source_default.hex(COLORS.primary)("  Paste bot token (enter to keep current): ") : source_default.hex(COLORS.primary)("  Paste bot token: ");
+    const tokenInput = await rl.question(tokenPrompt);
+    const botToken = tokenInput.trim() || existing?.botToken;
+    if (!botToken) {
+      console.log(source_default.hex(COLORS.error)("\n  No bot token provided. Setup cancelled."));
+      return;
+    }
+    if (!/^\d+:[A-Za-z0-9_-]+$/.test(botToken)) {
+      console.log(
+        source_default.hex(COLORS.error)("\n  Invalid token format. Expected: 123456789:ABCdef...")
+      );
+      return;
+    }
+    console.log(
+      source_default.hex(COLORS.accent)("\n  Step 2: User ID\n") + source_default.hex(COLORS.textDim)("    1. Open userinfobot: ") + source_default.hex(COLORS.primary).underline("https://t.me/userinfobot") + "\n" + source_default.hex(COLORS.textDim)("    2. Send any message \u2014 it replies with your numeric ID\n") + source_default.hex(COLORS.textDim)("    Only this user ID can control the boss.\n")
+    );
+    const userPrompt = existing ? source_default.hex(COLORS.primary)(`  Your Telegram user ID (enter to keep ${existing.userId}): `) : source_default.hex(COLORS.primary)("  Your Telegram user ID: ");
+    const userInput = await rl.question(userPrompt);
+    const userId = userInput.trim() ? parseInt(userInput.trim(), 10) : existing?.userId;
+    if (!userId || isNaN(userId)) {
+      console.log(source_default.hex(COLORS.error)("\n  Invalid user ID. Must be a number."));
+      return;
+    }
+    console.log(source_default.hex(COLORS.textDim)("\n  Verifying bot token..."));
+    const verifyRes = await fetch(`https://api.telegram.org/bot${botToken}/getMe`, {
+      method: "POST"
+    });
+    const verifyData = await verifyRes.json();
+    if (!verifyData.ok || !verifyData.result) {
+      console.log(
+        source_default.hex(COLORS.error)(
+          "\n  Invalid bot token \u2014 Telegram rejected it. Check and try again."
+        )
+      );
+      return;
+    }
+    const config = { botToken, userId };
+    await saveBossTelegramConfig(config);
+    console.log(
+      source_default.hex(COLORS.success)(
+        `
+  \u2713 Connected to @${verifyData.result.username} (${verifyData.result.first_name})
+`
+      ) + source_default.hex(COLORS.success)(`  \u2713 Authorized user ID: ${userId}
+
+`) + source_default.hex(COLORS.primary)("  To start:\n") + source_default.hex(COLORS.textDim)("    ggboss serve\n")
+    );
+  } finally {
+    rl.close();
+  }
+}
+function gradientText2(text) {
+  let i = 0;
+  return text.split("").map((ch) => ch === " " ? ch : source_default.hex(GRADIENT[i++ % GRADIENT.length])(ch)).join("");
+}
+function printSetupBanner() {
+  console.log();
+  console.log(
+    `  ${gradientText2(LOGO_LINES[0])}${LOGO_GAP}` + source_default.hex(COLORS.primary).bold(BRAND) + source_default.hex(COLORS.textDim)(` v${VERSION}`) + source_default.hex(COLORS.textDim)(" \xB7 By ") + source_default.white.bold(AUTHOR)
+  );
+  console.log(
+    `  ${gradientText2(LOGO_LINES[1])}${LOGO_GAP}` + source_default.hex(COLORS.accent)("Telegram Setup")
+  );
+  console.log(
+    `  ${gradientText2(LOGO_LINES[2])}${LOGO_GAP}` + source_default.hex(COLORS.textDim)("Remote Control")
+  );
+  console.log();
+}
+
 // src/orchestrator-app.tsx
 init_esm_shims();
 var import_react11 = __toESM(require_react(), 1);
@@ -903,7 +1778,7 @@ function projectColor(name) {
 }
 
 // src/tool-formatters.ts
-function truncate(s, max) {
+function truncate2(s, max) {
   if (max <= 1) return "\u2026";
   return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
 }
@@ -933,13 +1808,13 @@ var bossToolFormatters = {
         return "";
       case "get_worker_status":
       case "get_worker_summary":
-        return truncate(String(args.project ?? ""), 40);
+        return truncate2(String(args.project ?? ""), 40);
       case "prompt_worker": {
         const project = String(args.project ?? "");
         const message = String(args.message ?? "").replace(/\s+/g, " ");
         const fresh = args.fresh === true;
         const maxMsg = promptWorkerDetailLen(project) - (fresh ? 8 : 0);
-        const truncMsg = truncate(message, Math.max(15, maxMsg));
+        const truncMsg = truncate2(message, Math.max(15, maxMsg));
         const head = fresh ? "fresh \xB7 " : "";
         return project ? `${head}${project} \xB7 ${truncMsg}` : `${head}${truncMsg}`;
       }
@@ -1456,19 +2331,19 @@ function RadioPicker({
 // src/auto-update.ts
 init_esm_shims();
 import { spawn as spawn2 } from "child_process";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import os2 from "os";
 var PACKAGE_NAME = "@kenkaiiii/gg-boss";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 1e4;
 function getStateFilePath() {
-  return path3.join(os2.homedir(), ".gg", "boss", "update-state.json");
+  return path4.join(os2.homedir(), ".gg", "boss", "update-state.json");
 }
 function readState() {
   try {
-    const raw = fs3.readFileSync(getStateFilePath(), "utf-8");
+    const raw = fs4.readFileSync(getStateFilePath(), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1476,9 +2351,9 @@ function readState() {
 }
 function writeState(state) {
   try {
-    const dir = path3.dirname(getStateFilePath());
-    fs3.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs3.writeFileSync(getStateFilePath(), JSON.stringify(state));
+    const dir = path4.dirname(getStateFilePath());
+    fs4.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs4.writeFileSync(getStateFilePath(), JSON.stringify(state));
   } catch {
   }
 }
@@ -1770,7 +2645,7 @@ function BossAppInner({ boss, resetUI }) {
     }
     bossStore.appendUser(trimmed);
     setLastUserMessage(trimmed);
-    const scoped = scopePrefix(state.scope) + trimmed;
+    const scoped = scopePrefix2(state.scope) + trimmed;
     boss.enqueueUserMessage(scoped);
   };
   const handleAbort = () => {
@@ -1907,7 +2782,7 @@ function ScopePill({ scope }) {
     ] })
   ] });
 }
-function scopePrefix(scope) {
+function scopePrefix2(scope) {
   if (scope === "all") return "[scope:all] ";
   return `[scope:${scope}] `;
 }
@@ -2448,11 +3323,11 @@ function parseProjectSpec(raw) {
   const eq = raw.indexOf("=");
   if (eq > 0) {
     const name = raw.slice(0, eq);
-    const cwd2 = path4.resolve(raw.slice(eq + 1));
+    const cwd2 = path5.resolve(raw.slice(eq + 1));
     return { name, cwd: cwd2 };
   }
-  const cwd = path4.resolve(raw);
-  return { name: path4.basename(cwd), cwd };
+  const cwd = path5.resolve(raw);
+  return { name: path5.basename(cwd), cwd };
 }
 function parseArgs(argv) {
   const args = {
@@ -2490,10 +3365,54 @@ function printHelpAndExit() {
     "\n" + c(COLORS.primary, "GG Boss") + c(COLORS.textDim, " \u2014 orchestrator that drives multiple ggcoder workers from one chat.\n\n") + c(COLORS.text, "Usage\n") + "  " + c(COLORS.accent, "ggboss") + c(
       COLORS.textDim,
       "                              start orchestrator using linked projects\n"
-    ) + "  " + c(COLORS.accent, "ggboss link") + c(COLORS.textDim, "                         pick which projects to link (interactive)\n") + "  " + c(COLORS.accent, "ggboss continue") + c(COLORS.textDim, "                     resume the most recent boss session\n") + "  " + c(COLORS.accent, "ggboss --resume <id>") + c(COLORS.textDim, "                resume a specific boss session\n") + "  " + c(COLORS.accent, "ggboss --project <spec> [...]") + c(COLORS.textDim, "       override links with explicit project(s)\n\n") + c(COLORS.text, "Options\n") + "  " + c(COLORS.primary, "--project, -p <spec>") + c(COLORS.textDim, '    project to manage. spec is "cwd" or "name=cwd". repeatable.\n') + "  " + c(COLORS.primary, "--boss-model <id>") + c(COLORS.textDim, "       model for the orchestrator (default: claude-opus-4-7)\n") + "  " + c(COLORS.primary, "--worker-model <id>") + c(COLORS.textDim, "     model for workers (default: claude-sonnet-4-6)\n") + "  " + c(COLORS.primary, "--help, -h") + c(COLORS.textDim, "              show this help\n\n") + c(COLORS.textDim, "Talk to the boss at the prompt. Press ") + c(COLORS.accent, "Ctrl+C") + c(COLORS.textDim, " twice to exit.\n\n")
+    ) + "  " + c(COLORS.accent, "ggboss link") + c(COLORS.textDim, "                         pick which projects to link (interactive)\n") + "  " + c(COLORS.accent, "ggboss telegram") + c(COLORS.textDim, "                     configure Telegram bot integration\n") + "  " + c(COLORS.accent, "ggboss serve") + c(COLORS.textDim, "                        run the boss over Telegram (no TUI)\n") + "  " + c(COLORS.accent, "ggboss continue") + c(COLORS.textDim, "                     resume the most recent boss session\n") + "  " + c(COLORS.accent, "ggboss --resume <id>") + c(COLORS.textDim, "                resume a specific boss session\n") + "  " + c(COLORS.accent, "ggboss --project <spec> [...]") + c(COLORS.textDim, "       override links with explicit project(s)\n\n") + c(COLORS.text, "Options\n") + "  " + c(COLORS.primary, "--project, -p <spec>") + c(COLORS.textDim, '    project to manage. spec is "cwd" or "name=cwd". repeatable.\n') + "  " + c(COLORS.primary, "--boss-model <id>") + c(COLORS.textDim, "       model for the orchestrator (default: claude-opus-4-7)\n") + "  " + c(COLORS.primary, "--worker-model <id>") + c(COLORS.textDim, "     model for workers (default: claude-sonnet-4-6)\n") + "  " + c(COLORS.primary, "--help, -h") + c(COLORS.textDim, "              show this help\n\n") + c(COLORS.textDim, "Talk to the boss at the prompt. Press ") + c(COLORS.accent, "Ctrl+C") + c(COLORS.textDim, " twice to exit.\n\n")
   );
   process.exit(0);
 }
+async function runServeSubcommand(argv) {
+  let cliBotToken;
+  let cliUserId;
+  let cliBossModel;
+  let cliWorkerModel;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--bot-token") cliBotToken = argv[++i];
+    else if (a === "--user-id") cliUserId = argv[++i];
+    else if (a === "--boss-model") cliBossModel = argv[++i];
+    else if (a === "--worker-model") cliWorkerModel = argv[++i];
+    else if (a === "--help" || a === "-h") {
+      process.stdout.write(
+        "\nggboss serve \u2014 drive the boss from Telegram\n\nOptions\n  --bot-token <token>   Telegram bot token (or env GG_BOSS_TELEGRAM_BOT_TOKEN)\n  --user-id <id>        Allowed Telegram user ID (or env GG_BOSS_TELEGRAM_USER_ID)\n  --boss-model <id>     Override boss model\n  --worker-model <id>   Override worker model\n\nRun `ggboss telegram` first to save credentials interactively.\n\n"
+      );
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${a}`);
+    }
+  }
+  const saved = await loadBossTelegramConfig();
+  const botToken = cliBotToken ?? process.env.GG_BOSS_TELEGRAM_BOT_TOKEN ?? saved?.botToken;
+  const userIdStr = cliUserId ?? process.env.GG_BOSS_TELEGRAM_USER_ID;
+  const userId = userIdStr ? parseInt(userIdStr, 10) : saved?.userId;
+  if (!botToken || !userId || isNaN(userId)) {
+    process.stderr.write(
+      source_default.hex(COLORS.error)("Telegram not configured.\n\n") + "Run " + source_default.hex(COLORS.primary).bold("ggboss telegram") + " to set up your bot token and user ID.\n\n" + source_default.hex(COLORS.textDim)("Or provide manually:\n") + source_default.hex(COLORS.textDim)("  ggboss serve --bot-token TOKEN --user-id ID\n")
+    );
+    process.exit(1);
+  }
+  const settings = await loadSettings();
+  const bossProvider = settings.bossProvider ?? "anthropic";
+  const bossModel = cliBossModel ?? settings.bossModel ?? "claude-opus-4-7";
+  const workerProvider = settings.workerProvider ?? "anthropic";
+  const workerModel = cliWorkerModel ?? settings.workerModel ?? "claude-sonnet-4-6";
+  await runBossServeMode({
+    bossProvider,
+    bossModel,
+    bossThinkingLevel: settings.bossThinkingLevel,
+    workerProvider,
+    workerModel,
+    telegram: { botToken, userId }
+  });
+}
 async function runOrchestrator(args) {
   if (args.projects.length === 0) {
     const links = await loadLinks();
@@ -2556,6 +3475,14 @@ async function main() {
     await runLinkCommand();
     process.exit(0);
   }
+  if (argv[0] === "telegram") {
+    await runBossTelegramSetup();
+    process.exit(0);
+  }
+  if (argv[0] === "serve") {
+    await runServeSubcommand(argv.slice(1));
+    return;
+  }
   const isContinue = argv[0] === "continue";
   const args = parseArgs(isContinue ? argv.slice(1) : argv);
   if (isContinue) args.continueRecent = true;