pikiloom 0.4.26 → 0.4.28

package/dist/channels/feishu/render.js

@@ -1,9 +1,3 @@
-/**
- * Feishu-specific message card rendering.
- *
- * Converts structured data from bot/commands.ts into Feishu Markdown (for interactive cards).
- * Also provides a LivePreviewRenderer for streaming output.
- */
 import { encodeCommandAction } from '../../bot/command-ui.js';
 import { fmtUptime, fmtTokens, fmtBytes, formatGitStatusLine } from '../../bot/bot.js';
 import { summarizePromptForStatus } from '../../bot/commands.js';
@@ -12,9 +6,6 @@ export { dispatchImageBlocks } from '../../bot/render-shared.js';
 import { currentHumanLoopQuestion, humanLoopAnsweredCount, isHumanLoopAwaitingText, isHumanLoopQuestionAnswered, summarizeHumanLoopAnswer, } from '../../bot/human-loop.js';
 import path from 'node:path';
 import { listSubdirs } from '../../bot/bot.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
 function formatPreviewFooter(agent, elapsedMs, meta, decorations) {
     const parts = formatFooterParts(agent, elapsedMs, meta, null, decorations);
     return `${footerStatusSymbol('running')} ${parts.identity}\n*${parts.runtime}*`;
@@ -103,19 +94,9 @@ export function renderCommandSelectionCard(view) {
         rows: view.rows.map(row => ({ actions: row.map(actionButton) })),
     };
 }
-/**
- * Strip code-fence markers (``` / ~~~) from text that is not meant to be
- * rendered as full markdown (thinking, activity).  Truncation by
- * extractThinkingTail can leave stray fences that open unwanted code blocks.
- */
 function stripCodeFences(text) {
     return text.replace(/^(`{3,}|~{3,}).*$/gm, '');
 }
-/**
- * Ensure code fences in markdown text are balanced.  If an odd number of
- * fence markers is detected, append a closing fence so partial code blocks
- * do not swallow the rest of the card.
- */
 function ensureBalancedCodeFences(text) {
     let inCode = false;
     for (const line of text.split('\n')) {
@@ -179,11 +160,6 @@ export function buildHumanLoopPromptMarkdown(prompt) {
     }
     return lines.join('\n\n');
 }
-/**
- * Closed-state rendering for a resolved human-loop card. Collapsed to the
- * title + one row per question showing the chosen answer. No buttons, no
- * pending-state copy.
- */
 export function buildAnsweredHumanLoopPromptMarkdown(prompt, summary) {
     const symbol = summary.status === 'cancelled' ? '⊘' : '✓';
     const lines = [`**${symbol} ${prompt.title}**`];
@@ -194,9 +170,6 @@ export function buildAnsweredHumanLoopPromptMarkdown(prompt, summary) {
     }
     return lines.join('\n');
 }
-// ---------------------------------------------------------------------------
-// LivePreview renderer — produces Markdown for Feishu card elements
-// ---------------------------------------------------------------------------
 export function buildInitialPreviewMarkdown(agent, model, effort, waiting = false, queuePosition = 0) {
     const parts = [];
     if (waiting) {
@@ -217,8 +190,6 @@ function buildPreviewMarkdown(input, options) {
     const data = extractStreamPreviewData(input);
     const parts = [];
     if (data.planDisplay) {
-        // First line of planDisplay is already "Plan N/M" — promote it to the
-        // bold header instead of stacking a second "**Plan**" line above it.
         const text = stripCodeFences(data.planDisplay);
         const nl = text.indexOf('\n');
         parts.push(nl >= 0 ? `**${text.slice(0, nl)}**${text.slice(nl)}` : `**${text}**`);
@@ -230,7 +201,6 @@ function buildPreviewMarkdown(input, options) {
         parts.push(`**Sub-agent**\n${stripCodeFences(data.subAgentsDisplay)}`);
     }
     if (data.thinkDisplay && !data.display) {
-        // Elapsed lives in the footer only (single timer). Header is the bare label.
         parts.push(`**${data.label}**\n${stripCodeFences(data.thinkDisplay)}`);
     }
     else if (data.display) {
@@ -240,10 +210,6 @@ function buildPreviewMarkdown(input, options) {
         parts.push(ensureBalancedCodeFences(data.preview));
     }
     else if (data.thinkingProgressText) {
-        // Thinking phase with no streamed thinking/body text yet — show the bare
-        // "{thinkLabel}" so the card isn't blank. The elapsed tick lives in the
-        // footer only (one timer, not two); the footer re-renders on the channel
-        // heartbeat, so the card still visibly advances.
         parts.push(`**${data.label}**`);
     }
     if (options?.includeFooter !== false) {
@@ -292,9 +258,6 @@ export function buildFinalReplyRender(agent, result) {
         footerText,
     };
 }
-// ---------------------------------------------------------------------------
-// Command renderers — produce Markdown for Feishu cards
-// ---------------------------------------------------------------------------
 export function renderStart(d) {
     const lines = [
         `**${d.title}** v${d.version}`,
@@ -467,7 +430,6 @@ export function renderStatus(d) {
     if (d.running) {
         lines.push(`**Running:** ${fmtUptime(Date.now() - d.running.startedAt)} - ${summarizePromptForStatus(d.running.prompt)}`);
     }
-    // Provider usage
     const usageLines = buildProviderUsageLines(d.usage);
     if (usageLines.length > 1) {
         lines.push('');
@@ -483,9 +445,6 @@ export function renderStatus(d) {
     }
     return lines.join('\n');
 }
-// ---------------------------------------------------------------------------
-// Directory browser (interactive workdir switcher)
-// ---------------------------------------------------------------------------
 class PathRegistry {
     pathToId = new Map();
     idToPath = new Map();
@@ -520,7 +479,6 @@ export function buildSwitchWorkdirCard(currentWorkdir, browsePath, page = 0, opt
     const totalPages = Math.max(1, Math.ceil(dirs.length / DIR_PAGE_SIZE));
     const currentPage = Math.min(Math.max(0, page), totalPages - 1);
     const slice = dirs.slice(currentPage * DIR_PAGE_SIZE, (currentPage + 1) * DIR_PAGE_SIZE);
-    // Text
     const lines = ['**Workdir**'];
     lines.push(`● \`${currentWorkdir}\``);
     if (browsePath !== currentWorkdir)
@@ -528,7 +486,6 @@ export function buildSwitchWorkdirCard(currentWorkdir, browsePath, page = 0, opt
     if (opts.savedWorkspaceCount && opts.savedWorkspaceCount > 0) {
         lines.push('', `_Tip: ${opts.savedWorkspaceCount} saved workspace${opts.savedWorkspaceCount === 1 ? '' : 's'} — use /workspaces for one-tap switching._`);
     }
-    // Directory buttons (2 per row)
     const dirRows = [];
     for (let i = 0; i < slice.length; i += 2) {
         const rowActions = [];
@@ -539,7 +496,6 @@ export function buildSwitchWorkdirCard(currentWorkdir, browsePath, page = 0, opt
         }
         dirRows.push({ actions: rowActions });
     }
-    // Nav row: parent + pagination
     const navActions = [];
     const parent = path.dirname(browsePath);
     if (parent !== browsePath) {
@@ -552,7 +508,6 @@ export function buildSwitchWorkdirCard(currentWorkdir, browsePath, page = 0, opt
         if (currentPage < totalPages - 1)
             navActions.push(cardButton(`${currentPage + 2}/${totalPages} ▶`, `sw:n:${browseId}:${currentPage + 1}`));
     }
-    // Select button
     const selectActions = [
         cardButton('✓ Use This', `sw:s:${feishuPathRegistry.register(browsePath)}`, true),
     ];

package/dist/channels/health.js

@@ -1,38 +1,3 @@
-/**
- * Shared transport health tracker for IM channel listen / connect loops.
- *
- * Solves three problems each channel was reinventing:
- *
- *  1. **Exponential backoff** — initial → max with doubling between attempts,
- *     reset on success.
- *  2. **Log throttling** — continuous failures emit a log line only when the
- *     retry-delay bucket changes (1s → 2s → 4s → …), so identical failures
- *     don't flood the journal once per attempt.
- *  3. **Sustained-failure notice** — after a configurable threshold (5 min
- *     by default) of uninterrupted failures, emit a one-shot warn-level
- *     line pointing the operator at the relevant config. Retries continue
- *     indefinitely — the notice is informational, not a stop signal.
- *
- * Usage (long-poll style):
- *
- * ```ts
- * const health = new ChannelHealth({ label: 'Weixin', opAction: 'polling',
- *   initialDelayMs: 1_000, maxDelayMs: 60_000,
- *   sustainedFailureHint: 'verify baseUrl / token / accountId',
- *   log: (msg, level) => this.log(msg, level) });
- *
- * while (!stopping) {
- *   try {
- *     await poll();
- *     health.recordSuccess();
- *     // …process result…
- *   } catch (err) {
- *     if (stopping || isAbort(err)) break;
- *     await sleep(health.recordFailure(err));
- *   }
- * }
- * ```
- */
 function describeError(error) {
     return error instanceof Error ? error.message : String(error ?? 'unknown error');
 }
@@ -61,10 +26,6 @@ export class ChannelHealth {
         this.transientFailureLevel = opts.transientFailureLevel ?? 'warn';
         this.delayMs = opts.initialDelayMs;
     }
-    /**
-     * Mark the operation as currently succeeding. Resets backoff state and,
-     * if there were prior failures, emits an info-level recovery line.
-     */
     recordSuccess() {
         if (this.consecutiveFailures > 0 && this.firstFailureAt !== null) {
             const downtimeMs = Date.now() - this.firstFailureAt;
@@ -77,12 +38,6 @@ export class ChannelHealth {
         this.lastLoggedDelayMs = 0;
         this.sustainedNoticeFired = false;
     }
-    /**
-     * Record a failure. Emits the per-bucket failure log (throttled) and the
-     * one-shot sustained-failure notice when applicable, then advances the
-     * backoff for the *next* failure. Returns the delay (ms) the caller
-     * should sleep before its next attempt.
-     */
     recordFailure(error) {
         this.consecutiveFailures += 1;
         if (this.firstFailureAt === null)
@@ -102,7 +57,6 @@ export class ChannelHealth {
         this.delayMs = Math.min(this.delayMs * 2, this.maxDelayMs);
         return delayMs;
     }
-    /** Current consecutive failure count. */
     get failureCount() {
         return this.consecutiveFailures;
     }

package/dist/channels/slack/bot.js

@@ -1,10 +1,3 @@
-/**
- * Slack bot orchestration.
- *
- * Mirrors WeixinBot's command surface (/help, /status, /agent, /models, …)
- * over Slack channels and DMs. Each Slack channel id is a chat key, threads
- * are reused so the bot's reply lands in the same conversation as the trigger.
- */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';

package/dist/channels/slack/channel.js

@@ -1,17 +1,3 @@
-/**
- * Slack channel transport — Socket Mode (no public IP needed).
- *
- * Uses @slack/socket-mode + @slack/web-api directly (avoids the heavier Bolt
- * framework so we keep tight control of the receive loop and stay consistent
- * with the other channels).
- *
- * Two tokens are required:
- *   - bot token  (xoxb-…) — REST send/edit
- *   - app token  (xapp-…) — Socket Mode connection
- *
- * Receives DMs and messages where the bot is mentioned in a channel. Messages
- * the bot itself authored are filtered out before dispatch.
- */
 import { SocketModeClient } from '@slack/socket-mode';
 import { WebClient } from '@slack/web-api';
 import { Channel, DEFAULT_CHANNEL_CAPABILITIES, splitText, sleep, } from '../base.js';
@@ -26,7 +12,7 @@ export class SlackChannel extends Channel {
     capabilities = {
         ...DEFAULT_CHANNEL_CAPABILITIES,
         editMessages: true,
-        typingIndicators: false, // chat.postMessage with thread_ts emulates ack
+        typingIndicators: false,
     };
     knownChats = new Set();
     botToken;
@@ -40,7 +26,6 @@ export class SlackChannel extends Channel {
     listenResolve = null;
     messageHandlers = new Set();
     errorHandlers = new Set();
-    /** Dedup: Slack delivers events at-least-once via Socket Mode acks. */
     seenEventIds = new Set();
     seenEventQueue = [];
     static SEEN_EVENT_CAP = 256;
@@ -53,9 +38,6 @@ export class SlackChannel extends Channel {
     }
     onMessage(handler) { this.messageHandlers.add(handler); return this; }
     onError(handler) { this.errorHandlers.add(handler); return this; }
-    // ========================================================================
-    // Lifecycle
-    // ========================================================================
     async connect() {
         this.webClient = new WebClient(this.botToken);
         let lastErr = null;
@@ -85,7 +67,6 @@ export class SlackChannel extends Channel {
         this.running = true;
         this.socketClient = new SocketModeClient({
             appToken: this.appToken,
-            // We log via our own scope; suppress noisy SDK info logs.
             logLevel: undefined,
         });
         this.socketClient.on('message', async ({ event, ack }) => {
@@ -157,9 +138,6 @@ export class SlackChannel extends Channel {
         this.listenResolve?.();
         this.listenResolve = null;
     }
-    // ========================================================================
-    // Outgoing primitives
-    // ========================================================================
     async send(chatId, text, opts = {}) {
         const channelId = String(chatId);
         const chunks = splitText((text || '').trim() || '(empty)', SLACK_MAX);
@@ -208,11 +186,7 @@ export class SlackChannel extends Channel {
         catch { }
     }
     async sendTyping(_chatId, _opts) {
-        // Slack does not expose a typing indicator in the public API.
     }
-    // ========================================================================
-    // Internal dispatch
-    // ========================================================================
     async dispatchMessageEvent(event) {
         if (!event || event.bot_id || event.subtype === 'bot_message')
             return;

package/dist/channels/states.js

@@ -1,6 +1,3 @@
-/**
- * Channel validation state caching.
- */
 export function shouldCacheChannelStates(channels) {
     return channels.every(channel => !channel.configured || channel.validated);
 }

package/dist/channels/telegram/bot.js

@@ -1,10 +1,3 @@
-/**
- * Telegram bot orchestration: commands, callbacks, streaming lifecycle.
- *
- * Rendering, workdir browsing, and live preview state live in dedicated helper modules.
- * New IM integrations should stay parallel to this file and compose shared runtime helpers
- * instead of growing a single multi-platform bot entrypoint.
- */
 import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -24,17 +17,10 @@ import { currentHumanLoopQuestion, humanLoopOptionSelected } from '../../bot/hum
 import { TelegramChannel } from './channel.js';
 import { splitText, supportsChannelCapability } from '../base.js';
 import { getActiveUserConfig, loadKnownChatIds } from '../../core/config/user-config.js';
-/** Telegram HTML renderer for LivePreview. */
 const telegramPreviewRenderer = {
     renderInitial: buildInitialPreviewHtml,
     renderStream: buildStreamPreviewHtml,
 };
-/**
- * Echo message rendered after a human-loop prompt resolves — a small chat
- * message that records the decision in the conversation history (independent
- * of the now-closed card above). Returns null when there's nothing useful to
- * say (e.g. an empty cancellation).
- */
 function buildInteractionEchoHtml(summary) {
     if (summary.status === 'cancelled') {
         return `<i>⊘ Prompt cancelled.</i>`;
@@ -54,9 +40,6 @@ const SHUTDOWN_EXIT_CODE = {
     SIGINT: 130,
     SIGTERM: 143,
 };
-// ---------------------------------------------------------------------------
-// TelegramBot
-// ---------------------------------------------------------------------------
 export class TelegramBot extends Bot {
     token;
     channel;
@@ -70,15 +53,10 @@ export class TelegramBot extends Bot {
     constructor() {
         super();
         const config = getActiveUserConfig();
-        // merge Telegram-specific allowed IDs into base
         if (config.telegramAllowedChatIds) {
             for (const id of parseAllowedChatIds(config.telegramAllowedChatIds))
                 this.allowedChatIds.add(id);
         }
-        // NOTE: persisted known chats are restored into channel.knownChats in run()
-        // (for the startup greeting / per-chat menu) — deliberately NOT into
-        // allowedChatIds. allowedChatIds is the explicit allowlist; folding known
-        // chats into it flips _isAllowed() into allowlist-only mode.
         this.token = String(config.telegramBotToken || process.env.TELEGRAM_BOT_TOKEN || '').trim();
         if (!this.token)
             throw new Error('Missing Telegram token. Configure via dashboard or set TELEGRAM_BOT_TOKEN');
@@ -100,13 +78,9 @@ export class TelegramBot extends Bot {
         const mergedAllowed = parseAllowedChatIds(process.env.PIKILOOM_ALLOWED_IDS || '');
         for (const id of parseAllowedChatIds(String(config.telegramAllowedChatIds || '')))
             mergedAllowed.add(id);
-        // Known chats are NOT merged here — doing so would re-pollute the allowlist on
-        // every config reload. They live in channel.knownChats (restored in run()).
         this.allowedChatIds = mergedAllowed;
     }
-    /** Skill command prefix used in Telegram bot commands. */
     static SKILL_CMD_PREFIX = SKILL_CMD_PREFIX;
-    /** Register bot menu commands. Called automatically after connect. */
     async setupMenu() {
         if (!supportsChannelCapability(this.channel, 'commandMenu'))
             return;
@@ -156,9 +130,6 @@ export class TelegramBot extends Bot {
         shutdownAllDrivers();
     }
     buildRestartEnv() {
-        // Hand off only the explicit allowlist. Known chats persist to setting.json
-        // and are restored via loadKnownChatIds, so they must NOT ride along in the
-        // allowlist env — that would re-pollute allowedChatIds on the next boot.
         return buildKnownChatEnv(this.allowedChatIds, [], 'TELEGRAM_ALLOWED_CHAT_IDS');
     }
     beginShutdown(sig) {
@@ -224,7 +195,6 @@ export class TelegramBot extends Bot {
             return selected;
         return this.ensureSession(ctx.chatId, text, files);
     }
-    // ---- commands -------------------------------------------------------------
     async cmdStart(ctx) {
         const d = getStartData(this, ctx.chatId);
         await ctx.reply(this.renderStartHtml(d), { parseMode: 'HTML' });
@@ -257,7 +227,6 @@ export class TelegramBot extends Bot {
         const { getExtensionSummaryData } = await import('../../bot/commands.js');
         const data = getExtensionSummaryData(this, ctx.chatId);
         const lines = ['<b>Extensions</b>', ''];
-        // MCP servers
         lines.push(`<b>MCP Servers</b> (${data.mcpCount})`);
         if (data.mcpExtensions.length === 0) {
             lines.push('  <i>No MCP extensions configured</i>');
@@ -272,7 +241,6 @@ export class TelegramBot extends Bot {
             }
         }
         lines.push('');
-        // Skills
         lines.push(`<b>Skills</b> (${data.skillCount})`);
         if (data.skills.length === 0) {
             lines.push('  <i>No skills installed</i>');
@@ -513,12 +481,6 @@ export class TelegramBot extends Bot {
             this.debug(`[human-loop] echo send failed chat=${chatId} prompt=${prompt.promptId}: ${err?.message || err}`);
         }
     }
-    /**
-     * IM presenter for programmatic submissions (e.g. /goal-driven turns) so
-     * they stream to Telegram the same way a typed message does — placeholder
-     * card, LivePreview edits, sendFinalReply at the end. Without this, /goal
-     * just emits a confirmation reply and the rest of the turn is invisible.
-     */
     async createImTaskPresenter(opts) {
         if (typeof opts.chatId !== 'number')
             return null;
@@ -608,9 +570,7 @@ export class TelegramBot extends Bot {
         if (typeof sent === 'number')
             this.registerHumanLoopMessage(prompt.promptId, sent);
     }
-    /** Cache the messageThreadId per task so renderInteractionPrompt can use it. */
     interactionThreadIds = new Map();
-    // ---- streaming bridge -----------------------------------------------------
     async handleMessage(msg, ctx) {
         const text = msg.text.trim();
         if (!text && !msg.files.length)
@@ -622,7 +582,6 @@ export class TelegramBot extends Bot {
                 await ctx.reply('Please answer the active prompt using the buttons above.');
                 return;
             }
-            // Completed prompts close themselves via onInteractionAnswered.
             if (!result.completed)
                 await this.refreshHumanLoopPrompt(ctx.chatId, result.prompt.promptId);
             return;
@@ -725,7 +684,6 @@ export class TelegramBot extends Bot {
                     return;
                 }
                 this.emitStreamStart(taskId, session);
-                // Task is now running — update keyboard from Recall/Steer to Stop
                 const runningKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
                 if (phId != null && waiting) {
                     try {
@@ -752,7 +710,6 @@ export class TelegramBot extends Bot {
                     });
                     livePreview.start();
                 }
-                // MCP sendFile callback: sends files to IM in real-time during the stream
                 const mcpSendFile = this.createMcpSendFileCallback(ctx, messageThreadId);
                 this.interactionThreadIds.set(taskId, messageThreadId);
                 const result = await this.runStream(prompt, session, files, (nextText, nextThinking, nextActivity = '', meta, plan) => {
@@ -850,7 +807,6 @@ export class TelegramBot extends Bot {
             return [];
         }
     }
-    /** Create an MCP sendFile callback bound to a Telegram chat context. */
     createMcpSendFileCallback(ctx, messageThreadId) {
         return async (filePath, opts) => {
             try {
@@ -907,7 +863,6 @@ export class TelegramBot extends Bot {
             finalMsgId = await replacePreview(rendered.fullHtml);
         }
         else {
-            // Split: header on first message, footer on last message
             const maxFirst = 3900 - rendered.headerHtml.length;
             let firstBody;
             let remaining;
@@ -923,7 +878,6 @@ export class TelegramBot extends Bot {
                 remaining = rendered.bodyHtml;
             }
             if (remaining.trim()) {
-                // Multi-message: header on first, footer on last
                 const firstHtml = `${rendered.headerHtml}${firstBody}`;
                 finalMsgId = await replacePreview(firstHtml);
                 const chunks = splitText(remaining, 3800);
@@ -932,7 +886,6 @@ export class TelegramBot extends Bot {
                     const chunkText = isLast ? `${chunks[i]}${rendered.footerHtml}` : chunks[i];
                     remember(await sendFinalText(chunkText, finalMsgId ?? phId ?? anchor.replyTo));
                 }
-                // Safety: re-clear the Stop keyboard on the placeholder in case the first edit silently failed
                 if (phId != null) {
                     try {
                         await this.channel.editMessage(anchor.chatId, phId, firstHtml || '(done)', { parseMode: 'HTML', keyboard: { inline_keyboard: [] } });
@@ -941,14 +894,10 @@ export class TelegramBot extends Bot {
                 }
             }
             else {
-                // Body fits on first message; only footer pushes it over — keep together
                 const firstHtml = `${rendered.headerHtml}${firstBody}${rendered.footerHtml}`;
                 finalMsgId = await replacePreview(firstHtml);
             }
         }
-        // Dispatch any image MessageBlocks the agent produced this turn (Codex
-        // built-in `image_gen`, MCP / Skill tool_result images, …). Each goes out
-        // as a separate Telegram photo with the optional caption attached.
         const dispatched = await dispatchImageBlocks(this.channel, result.assistantBlocks, {
             chatId: anchor.chatId,
             replyTo: finalMsgId ?? phId ?? anchor.replyTo,
@@ -961,7 +910,6 @@ export class TelegramBot extends Bot {
         }
         return { primaryMessageId: finalMsgId, messageIds };
     }
-    // ---- callbacks ------------------------------------------------------------
     async handleSwitchNavigateCallback(data, ctx) {
         if (!data.startsWith('sw:n:'))
             return false;
@@ -1158,10 +1106,8 @@ export class TelegramBot extends Bot {
             }
         }
         catch {
-            // non-critical
         }
     }
-    // ---- command router -------------------------------------------------------
     async handleCommand(cmd, args, ctx) {
         try {
             switch (cmd) {
@@ -1211,7 +1157,6 @@ export class TelegramBot extends Bot {
                     await this.cmdRestart(ctx);
                     return;
                 default:
-                    // Intercept skill commands (sk_<name>) and route to agent
                     if (cmd.startsWith(TelegramBot.SKILL_CMD_PREFIX)) {
                         await this.cmdSkill(cmd, args, ctx);
                         return;
@@ -1224,7 +1169,6 @@ export class TelegramBot extends Bot {
             await ctx.reply(`Error: ${String(e).slice(0, 200)}`);
         }
     }
-    /** Execute a project-defined skill by routing it to the current agent. */
     async cmdSkill(cmd, args, ctx) {
         const resolved = resolveSkillPrompt(this, ctx.chatId, cmd, args);
         if (!resolved) {
@@ -1234,7 +1178,6 @@ export class TelegramBot extends Bot {
         this.log(`skill: ${resolved.skillName} agent=${this.chat(ctx.chatId).agent}${args.trim() ? ` args="${args.trim()}"` : ''}`);
         await this.handleMessage({ text: resolved.prompt, files: [] }, ctx);
     }
-    // ---- lifecycle ------------------------------------------------------------
     async run() {
         const tmpDir = path.join(os.tmpdir(), 'pikiloom');
         fs.mkdirSync(tmpDir, { recursive: true });
@@ -1256,9 +1199,6 @@ export class TelegramBot extends Bot {
             this.connected = true;
             this.log(`bot: @${bot.username} (id=${bot.id})`);
             this.channel.skipPendingUpdatesOnNextListen();
-            // Seed knownChats so setupMenu applies per-chat commands and the startup
-            // greeting can reach them: the explicit allowlist + persisted known chats
-            // (restored here instead of via allowedChatIds, which stays explicit-only).
             for (const cid of this.allowedChatIds)
                 if (typeof cid === 'number')
                     this.channel.knownChats.add(cid);