codeep 3.0.0 → 3.1.1

package/dist/config/index.d.ts

@@ -88,6 +88,12 @@ export interface ConfigSchema {
      *  and waiting on an answer that cannot come would hang CI. The bot token
      *  lives in the keychain, never here. */
     telegramApproval: boolean;
+    /** Whether a message from the configured chat becomes a prompt.
+     *
+     *  Separate from telegramApproval on purpose. Approval lets the phone answer
+     *  a question the agent already chose to ask; this lets the phone ask one,
+     *  which is a keyboard attached to this machine. Off unless asked for. */
+    telegramInbox: boolean;
     /** The single chat allowed to answer. Not a secret — it identifies a
      *  conversation, and it is useless without the token. */
     telegramChatId: string;

package/dist/config/index.js

@@ -152,6 +152,7 @@ function createConfig() {
         customBaseUrl: '',
         agentConfirmation: 'dangerous',
         telegramApproval: false,
+        telegramInbox: false,
         telegramChatId: '',
         agentConfirmDeleteFile: true,
         agentConfirmExecuteCommand: true,

package/dist/config/providers.js

@@ -477,7 +477,8 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'claude-fable-5', name: 'Claude Fable 5', description: 'Most capable — hardest reasoning & long-horizon agentic work' },
+            { id: 'claude-fable-5-1', name: 'Claude Fable 5.1', description: 'Most capable — hardest reasoning & long-horizon agentic work' },
+            { id: 'claude-fable-5', name: 'Claude Fable 5', description: 'Superseded by 5.1 — same price, kept for pinned configs' },
             { id: 'claude-opus-5', name: 'Claude Opus 5', description: 'Complex agentic coding & deep reasoning — the Opus workhorse' },
             { id: 'claude-sonnet-5', name: 'Claude Sonnet 5', description: 'Best balance of speed and intelligence' },
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku', description: 'Fastest and most affordable' },
@@ -528,7 +529,8 @@ export const PROVIDERS = {
         // get a working dropdown.
         models: [
             { id: 'openrouter/auto', name: 'Auto-route', description: 'OpenRouter picks the best model for the task' },
-            { id: 'anthropic/claude-fable-5', name: 'Claude Fable 5', description: 'Anthropic — most capable' },
+            { id: 'anthropic/claude-fable-5-1', name: 'Claude Fable 5.1', description: 'Anthropic — most capable' },
+            { id: 'anthropic/claude-fable-5', name: 'Claude Fable 5', description: 'Anthropic — superseded by 5.1' },
             { id: 'anthropic/claude-opus-5', name: 'Claude Opus 5', description: 'Anthropic — flagship Opus tier' },
             { id: 'anthropic/claude-sonnet-5', name: 'Claude Sonnet 5', description: 'Anthropic — balanced' },
             { id: 'openai/gpt-5.6-sol', name: 'GPT-5.6 Sol', description: 'OpenAI — flagship' },

package/dist/renderer/App.d.ts

@@ -20,7 +20,7 @@ export interface ConfirmOptions {
     onConfirm: () => void;
     onCancel?: () => void;
 }
-export { HunkPickerItem, HunkPickerOptions } from './components/HunkPicker';
+export type { HunkPickerItem, HunkPickerOptions } from './components/HunkPicker';
 import { type HunkPickerOptions } from './components/HunkPicker';
 /**
  * Options for the interactive hunk picker — see components/HunkPicker.ts.
@@ -492,6 +492,10 @@ export declare class App {
     /**
      * Render status bar
      */
+    /**
+     * @param canScroll false when the caller renders instead of the transcript
+     *   rather than above it, so there is nothing on screen for PgDn to move.
+     */
     private renderStatusBar;
     /**
      * Get visible messages (including streaming)

package/dist/renderer/App.js

@@ -1469,7 +1469,7 @@ export class App {
         // Input (don't render cursor when menu/settings is open)
         this.renderInput(inputLine, width, this.menuOpen || this.settingsOpen);
         // Status bar
-        this.renderStatusBar(statusLine, width);
+        this.renderStatusBar(statusLine, width, true);
         // Inline menu renders BELOW status bar
         if (this.menuOpen && this.menuItems.length > 0) {
             this.renderInlineMenu(statusLine + 1, width);
@@ -1707,7 +1707,7 @@ export class App {
         this.renderInput(inputY, width, false);
         this.renderAgentKeyHints(hintsY, width);
         this.screen.horizontalLine(footerDividerY, '─', fg.gray);
-        this.renderStatusBar(statusY, width);
+        this.renderStatusBar(statusY, width, false);
         this.screen.render();
     }
     renderAgentContextRail(dividerX, top, bottom, railWidth, timeline) {
@@ -2424,7 +2424,11 @@ export class App {
     /**
      * Render status bar
      */
-    renderStatusBar(y, width) {
+    /**
+     * @param canScroll false when the caller renders instead of the transcript
+     *   rather than above it, so there is nothing on screen for PgDn to move.
+     */
+    renderStatusBar(y, width, canScroll) {
         // Clear the line first
         this.screen.writeLine(y, '');
         if (this.notification) {
@@ -2441,8 +2445,12 @@ export class App {
             unseenWhileScrolled: this.unseenWhileScrolled,
             isStreaming: this.isStreaming,
             isLoading: this.isLoading,
+            canScroll,
         });
-        if (this.scrollOffset > 0 && this.unseenWhileScrolled > 0) {
+        // Only the badge replaces the footer. Without the guard a run wide enough
+        // to show the timeline traded its runtime and token counts for a hint that
+        // did nothing.
+        if (canScroll && this.scrollOffset > 0 && this.unseenWhileScrolled > 0) {
             this.screen.write(width - rightText.length, y, rightText, PRIMARY_COLOR);
             return;
         }

package/dist/renderer/agentExecution.js

@@ -9,6 +9,9 @@ import { chat } from '../api/index.js';
 import { runAgent } from '../utils/agent.js';
 import { TelegramApproval, outcomeForAnswer, describePermissionOutcome } from '../utils/telegramApproval.js';
 import { loadTelegramCredentials } from '../utils/telegramCredentials.js';
+import { composeRunMessages, sendTelegramNotice, shouldNotify } from '../utils/telegramNotify.js';
+import { takeRunFromPhone } from '../utils/telegramInbox.js';
+import { isFlatFeeProvider } from '../config/providers.js';
 import { raceApproval } from '../utils/approvalRace.js';
 import { describeAuditTarget } from '../utils/auditLog.js';
 import { config, autoSaveSession, getCurrentSessionId } from '../config/index.js';
@@ -167,6 +170,12 @@ export async function executeAgentTask(task, dryRun, ctx) {
         const telegramCredentials = confirmationMode === 'dangerous'
             ? await loadTelegramCredentials()
             : null;
+        // The finish notice does not depend on the confirmation mode — a run with
+        // confirmations off is exactly the one you are most likely to walk away
+        // from. Reuse the credentials already read above when there are any, so
+        // this costs a second keychain round-trip only when there are not.
+        const noticeCredentials = telegramCredentials ?? await loadTelegramCredentials();
+        const runStartedAt = Date.now();
         const onRequestPermission = confirmationMode === 'dangerous'
             ? async (toolCall) => {
                 // `parameters.command` is the binary alone — `git`, not `git status`.
@@ -411,12 +420,31 @@ export async function executeAgentTask(task, dryRun, ctx) {
         // Report stats to codeep.dev (fire-and-forget, only if github_id is set)
         const { getCurrentVersion } = await import('../utils/update.js');
         const sessionId = getCurrentSessionId();
-        // Auto-name from task if no display name set yet
-        if (!ctx.sessionDisplayName && ctx.setSessionDisplayName) {
-            const taskWords = task.replace(/\s+/g, ' ').trim().split(' ').slice(0, 5).join(' ');
-            ctx.setSessionDisplayName(taskWords.length > 48 ? taskWords.slice(0, 45) + '…' : taskWords);
+        // Auto-name from the task if no display name is set yet.
+        //
+        // The derived name is kept in a local rather than read back off ctx.
+        // makeCtx() copies sessionDisplayName by value, so setSessionDisplayName
+        // updates the module's variable while this object keeps the undefined it
+        // was built with — and reading it one line after calling the setter always
+        // returned nothing. Everything downstream then fell back to the session id,
+        // so a run reported itself to the dashboard, and announced itself on
+        // Telegram, as "session-2026-09-02-ddc1f13c" instead of its task.
+        const shortLabel = (text) => {
+            const words = text.replace(/\s+/g, ' ').trim().split(' ').slice(0, 5).join(' ');
+            return words.length > 48 ? words.slice(0, 45) + '…' : words;
+        };
+        // What THIS run was asked to do. The session name below is the first task's
+        // and stays put, which is right for a session and wrong for one run inside
+        // it: the second task in a session would otherwise announce itself on
+        // Telegram under the first one's name.
+        const runLabel = shortLabel(task) || sessionId;
+        let displayName = ctx.sessionDisplayName;
+        if (!displayName) {
+            displayName = shortLabel(task);
+            ctx.setSessionDisplayName?.(displayName);
         }
-        const displayName = ctx.sessionDisplayName || sessionId;
+        if (!displayName)
+            displayName = sessionId;
         syncSession({
             sessionId,
             sessionName: displayName,
@@ -428,6 +456,35 @@ export async function executeAgentTask(task, dryRun, ctx) {
         // even if the user switched model mid-session. Only this run's delta
         // (since tokenReportStart) is reported; the cumulative store is preserved.
         const costBreakdown = getCostBreakdown(tokenReportStart);
+        // Told once the run is over, and only when it ran long enough that you
+        // could plausibly have stopped watching. Awaited so the process does not
+        // exit from under the request, but never allowed to fail the run.
+        if (noticeCredentials) {
+            const elapsedMs = Date.now() - runStartedAt;
+            // Consumed once per run either way, so a phone-started run cannot leave
+            // the flag set for whatever the terminal does next.
+            const fromPhone = takeRunFromPhone();
+            // The one-minute threshold exists so a phone is not buzzed about work you
+            // watched finish. It has no business gating a run the phone itself asked
+            // for: that answer was wanted whether it took ten seconds or ten minutes,
+            // and withholding it leaves "Started —" as the last word.
+            if (fromPhone || shouldNotify(elapsedMs, true)) {
+                const payPerUse = costBreakdown.filter(entry => !isFlatFeeProvider(entry.provider));
+                // Usually one message. An answer past Telegram's limit continues into
+                // further ones rather than being cut at the first — awaited in turn so
+                // they arrive in the order they were written.
+                const messages = composeRunMessages({
+                    task: runLabel,
+                    elapsedMs,
+                    answer: fromPhone ? result.finalResponse : undefined,
+                    tokens: costBreakdown.reduce((sum, e) => sum + e.promptTokens + e.completionTokens, 0),
+                    costUsd: payPerUse.reduce((sum, e) => sum + e.estimatedCost, 0),
+                });
+                for (const message of messages) {
+                    await sendTelegramNotice(noticeCredentials, message).catch(() => false);
+                }
+            }
+        }
         const sharedFields = {
             sessionId,
             sessionName: displayName,

package/dist/renderer/components/Settings.js

@@ -136,6 +136,17 @@ export const SETTINGS = [
             { value: false, label: 'OFF' },
         ],
     },
+    {
+        key: 'telegramInbox',
+        label: 'Start tasks from Telegram',
+        getValue: () => config.get('telegramInbox') === true,
+        type: 'select',
+        // Booleans, for the same reason as the row above.
+        options: [
+            { value: true, label: 'ON' },
+            { value: false, label: 'OFF' },
+        ],
+    },
     {
         key: 'telegramChatId',
         label: 'Telegram chat ID',

package/dist/renderer/index.d.ts

@@ -6,10 +6,16 @@
  * with diff-based rendering for flicker-free updates.
  */
 export { cursor, screen, fg, bg, style, styled, stripAnsi, visibleLength, truncate, wordWrap } from './ansi';
-export { Screen, Cell } from './Screen';
-export { Input, LineEditor, KeyEvent, KeyHandler } from './Input';
-export { App, AppOptions, Message } from './App';
-export { createBox, centerBox, BoxStyle, BoxOptions } from './components/Box';
-export { renderModal, renderHelpModal, renderListModal, ModalOptions } from './components/Modal';
+export { Screen } from './Screen';
+export type { Cell } from './Screen';
+export { Input, LineEditor } from './Input';
+export type { KeyEvent, KeyHandler } from './Input';
+export { App } from './App';
+export type { AppOptions, Message } from './App';
+export { createBox, centerBox } from './components/Box';
+export type { BoxStyle, BoxOptions } from './components/Box';
+export { renderModal, renderHelpModal, renderListModal } from './components/Modal';
+export type { ModalOptions } from './components/Modal';
 export { helpCategories, keyboardShortcuts } from './components/Help';
-export { renderStatusScreen, StatusInfo } from './components/Status';
+export { renderStatusScreen } from './components/Status';
+export type { StatusInfo } from './components/Status';

package/dist/renderer/layout.d.ts

@@ -145,6 +145,13 @@ export declare function statusBarRightHint(args: {
     unseenWhileScrolled: number;
     isStreaming: boolean;
     isLoading: boolean;
+    /**
+     * False while something else owns the whole screen — the agent timeline
+     * takes it over and returns before the transcript is drawn at all, so
+     * scrolling changes an offset nothing reads. Offering PgDn there asks for a
+     * keypress that does nothing and leaves the reader hunting for the key.
+     */
+    canScroll: boolean;
 }): string;
 /** The panel that currently owns keyboard focus, in priority order. */
 export type ActivePanel = 'pasteInfo' | 'permission' | 'sessionPicker' | 'confirm' | 'status' | 'help' | 'settings' | 'search' | 'export' | 'logout' | 'login' | 'menu' | 'autocomplete' | 'hunkPicker' | 'chat';

package/dist/renderer/layout.js

@@ -213,7 +213,7 @@ export function formatTokenCount(tokens) {
  * scrolled up — otherwise the hint depends on whether work is in flight.
  */
 export function statusBarRightHint(args) {
-    if (args.scrollOffset > 0 && args.unseenWhileScrolled > 0) {
+    if (args.canScroll && args.scrollOffset > 0 && args.unseenWhileScrolled > 0) {
         return `↓ ${args.unseenWhileScrolled} new · PgDn `;
     }
     return args.isStreaming || args.isLoading ? 'Esc to stop ' : '/help · ↑↓ history ';

package/dist/renderer/main.js

@@ -22,6 +22,10 @@ import { expandFileAndFolderMentions, expandGitMentions } from '../utils/mention
 import { expandWebMentions } from '../utils/webFetch.js';
 import { handleCommand as dispatchCommand } from './commands.js';
 import { logAppError } from '../utils/logger.js';
+import { loadTelegramInboxCredentials } from '../utils/telegramCredentials.js';
+import { attachTelegramInbox } from '../utils/telegramInbox.js';
+import { sharedUpdates } from '../utils/telegramUpdates.js';
+import { sendTelegramNotice } from '../utils/telegramNotify.js';
 import { executeAgentTask, runAgentTask, } from './agentExecution.js';
 // ─── Global state ─────────────────────────────────────────────────────────────
 let projectPath = process.cwd();
@@ -50,6 +54,8 @@ export function deriveSessionName(message) {
     return words.length > 48 ? words.slice(0, 45) + '…' : words;
 }
 let isAgentRunningFlag = false;
+/** Set once the phone is allowed to send instructions; null when it is not. */
+let telegramInbox = null;
 let agentAbortController = null;
 let pendingInteractiveContext = null;
 // ─── Context factory ──────────────────────────────────────────────────────────
@@ -66,8 +72,14 @@ function makeCtx() {
         isAgentRunning: () => isAgentRunningFlag,
         // A finished run may have switched branches — drop the cache so the next
         // header render re-reads it.
-        setAgentRunning: (v) => { isAgentRunningFlag = v; if (!v)
-            gitBranchCache = null; },
+        setAgentRunning: (v) => {
+            isAgentRunningFlag = v;
+            if (!v) {
+                gitBranchCache = null;
+                // A run just ended: hand over anything the phone sent while it was busy.
+                telegramInbox?.drain();
+            }
+        },
         setAbortController: (ctrl) => { agentAbortController = ctrl; },
         formatAddedFilesContext,
         handleCommand: (cmd, args) => dispatchCommand(cmd, args, makeCtx()),
@@ -749,6 +761,38 @@ Commands (in chat):
     welcomeLines.push('  /help  ·  Ctrl+L clear  ·  Esc cancel');
     app.addMessage({ role: 'welcome', content: welcomeLines.join('\n') });
     app.start();
+    // Let the phone send instructions, if it has been switched on. Started after
+    // app.start() so a prompt that arrives immediately has somewhere to land.
+    void (async () => {
+        const credentials = await loadTelegramInboxCredentials();
+        if (!credentials)
+            return;
+        telegramInbox = attachTelegramInbox(credentials, {
+            isBusy: () => isAgentRunningFlag,
+            submit: (text) => {
+                // Through the same door the input box uses, and shown in the transcript
+                // the same way — a run started from the phone must not be invisible to
+                // whoever is sitting at the terminal.
+                app.addMessage({ role: 'user', content: text });
+                app.notify('Telegram: running an instruction from your phone');
+                app.setLoading(true);
+                void handleSubmit(text).catch(err => {
+                    app.notify(`Error: ${err.message}`);
+                    app.setLoading(false);
+                });
+            },
+            reply: (text) => { void sendTelegramNotice(credentials, text); },
+        });
+        // Say it once when the poll starts failing, and once when it recovers. A
+        // webhook left on the bot, or a revoked token, otherwise looks exactly like
+        // a phone nobody has messaged.
+        sharedUpdates(credentials.botToken).observe(({ ok, detail }) => {
+            if (ok)
+                app.notify(`Telegram: ${detail}`);
+            else
+                app.notifyWarn(`Telegram: ${detail}`);
+        });
+    })();
     // Spawn MCP servers in the background. They register against the fixed
     // session id `codeep-tui` that runAgentTask passes into runAgent's
     // `mcpSessionId` — so the agent picks up `.codeep/mcp_servers.json`

package/dist/utils/telegramApproval.d.ts

@@ -27,12 +27,9 @@
  */
 /** What the phone sent back. Mirrors the three buttons the desktop offers. */
 export type TelegramAnswer = 'run' | 'skip' | 'cancel';
-export interface TelegramCredentials {
-    /** From @BotFather. A credential — belongs in the keychain, never in config. */
-    botToken: string;
-    /** The single chat allowed to answer. Anything else is ignored. */
-    chatID: string;
-}
+import { type TelegramCredentials } from './telegramUpdates';
+export type { TelegramCredentials } from './telegramUpdates';
+export { nextOffset } from './telegramUpdates';
 /**
  * The message text.
  *
@@ -64,17 +61,6 @@ export declare function parseCallbackData(data: string): {
 /** The keyboard sent with the question. Shape pinned by a test — a renamed
  *  callback_data field would leave three buttons that silently do nothing. */
 export declare function buildKeyboard(token: string): Record<string, unknown>;
-/**
- * Advance the long-poll offset past everything just handled.
- *
- * Telegram redelivers any update that has not been acknowledged by a higher
- * offset, so getting this wrong means the same tap arrives forever. Exported
- * because it is off-by-one-shaped and cheaper to test than to debug against a
- * live bot.
- */
-export declare function nextOffset(current: number, updates: {
-    update_id?: unknown;
-}[]): number;
 /**
  * Telegram's three buttons, in the terms the agent's gate speaks.
  *
@@ -104,8 +90,8 @@ export declare function describeApiError(status: number, json: Record<string, un
 export declare class TelegramApproval {
     private readonly credentials;
     private outstanding;
-    private updateOffset;
-    private polling;
+    /** Set while a question is open; called to stop listening once it closes. */
+    private unlisten;
     /** Called once when the question could not be put at all. Not for a missing
      *  answer — only for a failure to ask. */
     private readonly onProblem?;
@@ -135,6 +121,5 @@ export declare class TelegramApproval {
     private post;
     private sendQuestion;
     private edit;
-    private poll;
     private handle;
 }

package/dist/utils/telegramApproval.js

@@ -26,6 +26,8 @@
  * one side is findable on the other.
  */
 const ANSWERS = ['run', 'skip', 'cancel'];
+import { sharedUpdates } from './telegramUpdates.js';
+export { nextOffset } from './telegramUpdates.js';
 /** Longest command we put in a message. Telegram caps at 4096 for the whole
  *  text; this keeps room for the heading and the fences, and a command longer
  *  than this is not something anyone reads off a phone anyway. */
@@ -99,22 +101,6 @@ export function buildKeyboard(token) {
             ]],
     };
 }
-/**
- * Advance the long-poll offset past everything just handled.
- *
- * Telegram redelivers any update that has not been acknowledged by a higher
- * offset, so getting this wrong means the same tap arrives forever. Exported
- * because it is off-by-one-shaped and cheaper to test than to debug against a
- * live bot.
- */
-export function nextOffset(current, updates) {
-    let out = current;
-    for (const update of updates) {
-        if (typeof update.update_id === 'number')
-            out = Math.max(out, update.update_id + 1);
-    }
-    return out;
-}
 /**
  * Telegram's three buttons, in the terms the agent's gate speaks.
  *
@@ -173,15 +159,13 @@ export function describeApiError(status, json) {
 }
 // ─── The client ───────────────────────────────────────────────────────────────
 const API = 'https://api.telegram.org';
-/** Server-side long-poll window. The request blocks for up to this long. */
-const POLL_SECONDS = 25;
-/** Local ceiling, comfortably past the server's own. */
-const REQUEST_TIMEOUT_MS = (POLL_SECONDS + 10) * 1000;
+/** Sending a message or editing one — no long poll lives here any more. */
+const REQUEST_TIMEOUT_MS = 15_000;
 export class TelegramApproval {
     credentials;
     outstanding = null;
-    updateOffset = 0;
-    polling = false;
+    /** Set while a question is open; called to stop listening once it closes. */
+    unlisten = null;
     /** Called once when the question could not be put at all. Not for a missing
      *  answer — only for a failure to ask. */
     onProblem;
@@ -212,7 +196,8 @@ export class TelegramApproval {
                     return;
                 settled = true;
                 this.outstanding = null;
-                this.polling = false;
+                this.unlisten?.();
+                this.unlisten = null;
                 resolve(answer);
             };
             this.outstanding = { token, messageID, resolve: finish };
@@ -223,7 +208,10 @@ export class TelegramApproval {
                 }
                 signal.addEventListener('abort', () => finish(null), { once: true });
             }
-            void this.poll();
+            // Listen on the bot's one poller rather than opening a second. Two
+            // cursors on the same bot silently eat each other's updates.
+            this.unlisten = sharedUpdates(this.credentials.botToken)
+                .subscribe('callback_query', callback => this.handle(callback));
         });
     }
     /**
@@ -235,7 +223,8 @@ export class TelegramApproval {
         if (!pending)
             return;
         this.outstanding = null;
-        this.polling = false;
+        this.unlisten?.();
+        this.unlisten = null;
         pending.resolve(null);
         await this.edit(pending.messageID, `Answered in the terminal — ${decidedInTerminal}.`);
     }
@@ -289,32 +278,6 @@ export class TelegramApproval {
             text,
         });
     }
-    async poll() {
-        if (this.polling)
-            return;
-        this.polling = true;
-        while (this.polling && this.outstanding) {
-            const json = await this.post('getUpdates', {
-                offset: this.updateOffset,
-                timeout: POLL_SECONDS,
-                allowed_updates: ['callback_query'],
-            });
-            if (!this.polling || !this.outstanding)
-                return;
-            const updates = Array.isArray(json?.result) ? json.result : [];
-            this.updateOffset = nextOffset(this.updateOffset, updates);
-            for (const update of updates) {
-                if (update.callback_query)
-                    await this.handle(update.callback_query);
-                if (!this.outstanding)
-                    return;
-            }
-            // Telegram's long poll already blocks server-side; this pause only covers
-            // the error case, so a failing network cannot spin the loop.
-            if (updates.length === 0)
-                await sleep(1000);
-        }
-    }
     async handle(callback) {
         const pending = this.outstanding;
         if (!pending)
@@ -328,7 +291,8 @@ export class TelegramApproval {
         if (!parsed || parsed.token !== pending.token)
             return;
         this.outstanding = null;
-        this.polling = false;
+        this.unlisten?.();
+        this.unlisten = null;
         const id = callback.id;
         if (typeof id === 'string')
             await this.post('answerCallbackQuery', { callback_query_id: id });
@@ -342,6 +306,3 @@ function randomToken() {
 function capitalise(value) {
     return value.charAt(0).toUpperCase() + value.slice(1);
 }
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}

package/dist/utils/telegramCredentials.d.ts

@@ -22,3 +22,11 @@ export declare function hasTelegramToken(): Promise<boolean>;
  * both would otherwise stall a run waiting for an answer that was never asked.
  */
 export declare function loadTelegramCredentials(): Promise<TelegramCredentials | null>;
+/**
+ * The same pair, for the inbox, behind its own switch.
+ *
+ * Not folded into the call above: someone can want the phone to be told a run
+ * finished without wanting the phone to be able to start one, and the reverse.
+ * One flag serving both would make turning either off turn both off.
+ */
+export declare function loadTelegramInboxCredentials(): Promise<TelegramCredentials | null>;

package/dist/utils/telegramCredentials.js

@@ -43,6 +43,21 @@ export async function loadTelegramCredentials() {
     // would be live while the settings row read OFF.
     if (config.get('telegramApproval') !== true)
         return null;
+    return readCredentials();
+}
+/**
+ * The same pair, for the inbox, behind its own switch.
+ *
+ * Not folded into the call above: someone can want the phone to be told a run
+ * finished without wanting the phone to be able to start one, and the reverse.
+ * One flag serving both would make turning either off turn both off.
+ */
+export async function loadTelegramInboxCredentials() {
+    if (config.get('telegramInbox') !== true)
+        return null;
+    return readCredentials();
+}
+async function readCredentials() {
     const chatID = String(config.get('telegramChatId') || '').trim();
     if (!chatID)
         return null;