@sayknow-cli/coding-agent 0.3.16 → 0.4.0

package/dist/types/notifications/telegram-daemon-control.d.ts

@@ -1,70 +0,0 @@
-/**
- * Telegram daemon controller + owner-scoped control-request helpers.
- *
- * Reload is a hybrid: an owner-scoped control-request file records auditable
- * intent, SIGTERM is the wakeup that aborts the in-flight long poll, and a
- * fresh daemon is spawned only after the old pid is dead / has exited. This
- * keeps the single-poller invariant (no Telegram getUpdates 409 overlap) and
- * never steals a still-live owner.
- */
-import type { Settings } from "../config/settings";
-import type { BuiltInDaemonController, DaemonOperationOptions, DaemonOperationResult, DaemonStatus } from "../daemon/control-types";
-import { type TelegramDaemonDeps, type TelegramDaemonFs } from "./telegram-daemon";
-export interface TelegramDaemonControlRequest {
-    version: 1;
-    requestId: string;
-    action: "reload" | "stop";
-    ownerId: string;
-    pid: number;
-    createdAt: number;
-}
-export declare function telegramControlRequestPath(agentDir: string): string;
-export declare function readTelegramControlRequest(settings: Settings, fsImpl?: TelegramDaemonFs): Promise<TelegramDaemonControlRequest | undefined>;
-export declare function writeTelegramControlRequest(settings: Settings, request: TelegramDaemonControlRequest, fsImpl?: TelegramDaemonFs): Promise<void>;
-export declare function clearTelegramControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;
-export interface TelegramDaemonControlDeps {
-    fs?: TelegramDaemonFs;
-    now?: () => number;
-    pidAlive?: (pid: number) => boolean;
-    sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
-    spawn?: TelegramDaemonDeps["spawn"];
-    execPath?: string;
-    /**
-     * Stable process id encoded into freshly-spawned daemon owner ids.
-     *
-     * The daemon-internal entrypoint rejects numeric owner ids whose process is
-     * already gone. `skc daemon reload` is a short-lived CLI process, so using its
-     * own pid can race the child startup and make the replacement exit immediately.
-     */
-    ownerPid?: number;
-    randomId?: () => string;
-    sleep?: (ms: number) => Promise<void>;
-    waitStepMs?: number;
-}
-export declare class TelegramDaemonController implements BuiltInDaemonController {
-    private readonly settings;
-    private readonly deps;
-    readonly kind: "telegram";
-    private readonly fsImpl;
-    private readonly now;
-    private readonly pidAlive;
-    private readonly sendSignal;
-    private readonly waitStepMs;
-    constructor(settings: Settings, deps?: TelegramDaemonControlDeps);
-    private runtimeInfo;
-    status(): Promise<DaemonStatus>;
-    private spawnDeps;
-    private sleep;
-    /**
-     * Wait until the captured pid is dead. Ownership-file movement is NOT treated
-     * as quiescence here: only actual process death proves the old poller stopped,
-     * which is what the no-409 invariant requires before spawning a fresh poller.
-     */
-    private waitForPidDeath;
-    private result;
-    reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
-    stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
-    private stopOrReload;
-    /** Clear our own control request unless a newer owner-scoped request replaced it. */
-    private clearOwnRequest;
-}

package/dist/types/notifications/telegram-daemon.d.ts

@@ -1,558 +0,0 @@
-import * as fs from "node:fs";
-import type { Settings } from "../config/settings";
-import type { DaemonRuntimeInfo } from "../daemon/control-types";
-import { HEARTBEAT_TTL_MS } from "./daemon-paths";
-import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
-import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
-import { type AliasTable, type CallbackRoute } from "./telegram-reference";
-export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
-export interface DaemonState {
-    pid: number;
-    ownerId: string;
-    tokenFingerprint: string;
-    chatId: string;
-    startedAt: number;
-    heartbeatAt: number;
-    roots: string[];
-    version: 1;
-    /**
-     * Operational daemon generation of the process that owns the lock, distinct
-     * from the persisted state-schema {@link DaemonState.version}. It records the
-     * wire generation ({@link DAEMON_GENERATION}) the owning daemon speaks so a
-     * freshly-upgraded host can detect — and reload — a still-live pre-upgrade
-     * daemon whose schema version is unchanged. Absent on pre-generation state.
-     */
-    generation?: number;
-    stoppedAt?: number;
-}
-export interface TelegramDaemonFs {
-    mkdir(path: string, opts?: fs.MakeDirectoryOptions): Promise<void>;
-    readFile(path: string, encoding: BufferEncoding): Promise<string>;
-    writeFile(path: string, data: string, opts?: fs.WriteFileOptions): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    unlink(path: string): Promise<void>;
-    open(path: string, flags: string, mode?: number): Promise<{
-        close(): Promise<void>;
-    }>;
-    readdir(path: string): Promise<string[]>;
-    chmod(path: string, mode: number): Promise<void>;
-}
-export interface SpawnResult {
-    unref?: () => void;
-}
-export interface TelegramDaemonDeps {
-    fs?: TelegramDaemonFs;
-    now?: () => number;
-    pid?: number;
-    pidAlive?: (pid: number) => boolean;
-    spawn?: (command: string, args: string[], opts: {
-        detached: boolean;
-        stdio: "ignore";
-        logPath?: string;
-    }) => SpawnResult;
-    execPath?: string;
-    randomId?: () => string;
-    /**
-     * Signal delivery + poll timing for the stale-generation reload handoff in
-     * {@link ensureTelegramDaemonRunning}. Defaults use real signals/timers; tests
-     * inject them to drive the handoff deterministically.
-     */
-    sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
-    sleep?: (ms: number) => Promise<void>;
-    waitStepMs?: number;
-}
-export declare const HEARTBEAT_INTERVAL_MS = 5000;
-export { HEARTBEAT_TTL_MS };
-export declare const DAEMON_VERSION = 1;
-/** Capability token advertised when the server supports app-level ping/pong. */
-export declare const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
-/** Protocol version the daemon advertises in its ClientHello. */
-export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
-/** Capability required for typed controls and semantic Selected acknowledgement frames. */
-export declare const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
-export declare const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
-/**
- * Operational generation the current daemon build speaks, persisted into
- * {@link DaemonState.generation} on ownership acquisition. It is tied to the
- * wire {@link NOTIFICATION_PROTOCOL_VERSION} so any protocol bump (which is what
- * gates capabilities like {@link ASK_SELECTED_ACK_CAPABILITY}) also bumps the
- * generation, letting a freshly-upgraded host recognise an older, still-live
- * daemon and reload it instead of silently attaching to it. Distinct from the
- * persisted schema {@link DAEMON_VERSION}, which did not change across #1999.
- */
-export declare const DAEMON_GENERATION = 3;
-export { type DaemonPaths, daemonPaths } from "./daemon-paths";
-/**
- * Attach session-lifecycle control (create/close/resume) to the running daemon.
- *
- * Wires an already-started, authenticated control server to the lifecycle
- * orchestrator with real daemon-side effects (tmux launcher / force-close /
- * resume), a durable fsynced idempotency ledger + audit JSONL under the agent
- * notifications dir, and strict paired-chat gating. The control server itself
- * (NotificationControlServer) is owned/started by the daemon process; this
- * function only connects it to policy. Returns the orchestrator deps for tests.
- */
-export declare function startDaemonLifecycleControl(input: {
-    controlServer: ControlServerLike;
-    pairedChatId: string;
-    agentDir: string;
-    env?: NodeJS.ProcessEnv;
-}): void;
-export declare function registerNotificationRoot(input: {
-    settings: Settings;
-    cwd: string;
-    sessionId: string;
-    fs?: TelegramDaemonFs;
-}): Promise<string>;
-export declare function isFreshLiveOwner(input: {
-    state: DaemonState | undefined;
-    now: number;
-    tokenFingerprint: string;
-    chatId: string;
-    pidAlive: (pid: number) => boolean;
-}): boolean;
-export declare function acquireDaemonOwnership(input: {
-    settings: Settings;
-    roots?: string[];
-    tokenFingerprint: string;
-    chatId: string;
-    fs?: TelegramDaemonFs;
-    now?: () => number;
-    pid?: number;
-    pidAlive?: (pid: number) => boolean;
-    randomId?: () => string;
-}): Promise<{
-    acquired: boolean;
-    ownerId?: string;
-    attached?: boolean;
-    blocked?: boolean;
-    reason?: "identity_mismatch";
-    reloadRequired?: boolean;
-}>;
-export declare function renewDaemonHeartbeat(input: {
-    settings: Settings;
-    ownerId: string;
-    fs?: TelegramDaemonFs;
-    now?: () => number;
-    pid?: number;
-}): Promise<boolean>;
-export declare function releaseDaemonOwnership(input: {
-    settings: Settings;
-    ownerId: string;
-    fs?: TelegramDaemonFs;
-    now?: () => number;
-}): Promise<void>;
-/** Read the persisted daemon ownership state (or undefined when absent). */
-export declare function readDaemonState(settings: Settings, fs?: TelegramDaemonFs): Promise<DaemonState | undefined>;
-/** Read the persisted notification roots list. */
-export declare function readDaemonRoots(settings: Settings, fs?: TelegramDaemonFs): Promise<string[]>;
-export interface TelegramSpawnOwnerInput {
-    settings: Settings;
-    roots?: string[];
-    tokenFingerprint: string;
-    chatId: string;
-}
-export interface TelegramSpawnOwnerResult {
-    result: EnsureDaemonResult;
-    ownerId?: string;
-    runtime: DaemonRuntimeInfo;
-    warnings: string[];
-    /**
-     * Set when ownership was NOT acquired because a still-live owner is running an
-     * older daemon generation. The caller must hand off via a reload rather than
-     * attach; see {@link ensureTelegramDaemonRunning}.
-     */
-    reloadRequired?: boolean;
-}
-/**
- * Build the detached spawn command/args for the daemon-internal entrypoint.
- * Source mode prepends the entry script so the respawn loads edited source;
- * a compiled binary self-spawns its own subcommand directly.
- */
-export declare function buildTelegramDaemonSpawnArgs(input: {
-    execPath?: string;
-    ownerId: string;
-    agentDir: string;
-}): {
-    command: string;
-    args: string[];
-    runtime: DaemonRuntimeInfo;
-};
-/**
- * Acquire ownership for the given Telegram identity and, if acquired, spawn a
- * fresh detached daemon process. Does NOT register notification roots; callers
- * that own a session (autostart) register roots separately, while reload reuses
- * already-persisted roots.
- */
-export declare function spawnTelegramDaemonOwner(input: TelegramSpawnOwnerInput, deps?: TelegramDaemonDeps): Promise<TelegramSpawnOwnerResult>;
-export declare function ensureTelegramDaemonRunning(input: {
-    settings: Settings;
-    cwd: string;
-    sessionId: string;
-}, deps?: TelegramDaemonDeps): Promise<EnsureDaemonResult>;
-export interface BotApi {
-    call(method: string, body: unknown, opts?: {
-        signal?: AbortSignal;
-        noRetry?: boolean;
-    }): Promise<unknown>;
-}
-export interface TelegramTransportOptions {
-    botToken: string;
-    apiBase?: string;
-    fetchImpl?: typeof fetch;
-    setTimeoutImpl?: typeof setTimeout;
-}
-/** Telegram Bot API transport: HTTP JSON/multipart details stay out of daemon orchestration. */
-export declare class TelegramBotTransport implements BotApi {
-    #private;
-    constructor(opts: TelegramTransportOptions);
-    call(method: string, body: unknown, opts?: {
-        signal?: AbortSignal;
-        noRetry?: boolean;
-    }): Promise<unknown>;
-}
-export type TelegramUpdateOutcome = "consumed" | "retry";
-export interface TelegramUpdatePollerOptions {
-    botApi: BotApi;
-    runtime: NotificationOperatorRuntime;
-    backoff: OperatorBackoffPolicy;
-    processUpdate: (update: unknown) => Promise<TelegramUpdateOutcome>;
-}
-/** Owns getUpdates offset, conflict backoff, and per-update error isolation. */
-export declare class TelegramUpdatePoller {
-    #private;
-    constructor(opts: TelegramUpdatePollerOptions);
-    pollOnce(signal?: AbortSignal): Promise<number>;
-}
-/** Mutable dispatch state shared by session frames and inbound Telegram updates. */
-export declare class TelegramEventDispatchState {
-    readonly busy: Set<string>;
-    readonly inboundReactions: Map<number, {
-        messageId: number;
-    }>;
-    readonly seenUpdateIds: Set<number>;
-}
-/**
- * Cooperative control seam for the daemon run loop. Implemented by the
- * daemon-internal CLI / controller against the owner-scoped control-request
- * file so the daemon does not import the control module directly.
- */
-export interface DaemonControlHooks {
-    /** Returns true when a stop/reload has been requested for this owner. */
-    shouldStop(ownerId: string): Promise<boolean>;
-    /** Clear a consumed control request (best-effort). */
-    clear?(ownerId: string): Promise<void>;
-}
-export interface TelegramDaemonOptions {
-    settings: Settings;
-    ownerId: string;
-    botToken: string;
-    chatId: string;
-    apiBase?: string;
-    fetchImpl?: typeof fetch;
-    fs?: TelegramDaemonFs;
-    WebSocketImpl?: typeof WebSocket;
-    now?: () => number;
-    setTimeoutImpl?: typeof setTimeout;
-    clearTimeoutImpl?: typeof clearTimeout;
-    setIntervalImpl?: typeof setInterval;
-    clearIntervalImpl?: typeof clearInterval;
-    idleTimeoutMs?: number;
-    scanIntervalMs?: number;
-    pid?: number;
-    /** Liveness probe for skipping dead-PID endpoint records in {@link TelegramNotificationDaemon.scanRoots}. */
-    pidAlive?: (pid: number) => boolean;
-    botApi?: BotApi;
-    control?: DaemonControlHooks;
-    /**
-     * Factory for the session-lifecycle control server. Defaults to the real
-     * native NotificationControlServer; tests inject a fake to verify the
-     * owner-bound start/stop lifecycle without a socket. When `undefined` AND no
-     * default applies (e.g. lifecycle control disabled), no control server starts.
-     */
-    createLifecycleControlServer?: LifecycleControlServerFactory | null;
-    /** Rich text promotion (enabled by default; see rich-render.ts). */
-    rich?: {
-        enabled: boolean;
-    };
-    /** Opt-in rich-draft streaming of live turn previews (off by default; see rich-draft.ts). */
-    richDraft?: {
-        enabled: boolean;
-    };
-    /**
-     * Per-session Telegram forum-topic naming. `nameTemplate` supports the
-     * `{repo}`, `{branch}`, and `{title}` placeholders; unset preserves the
-     * built-in `{repo}/{branch} - {title}` composition and its fallbacks.
-     */
-    topics?: {
-        nameTemplate?: string;
-    };
-}
-interface SessionSocket {
-    sessionId: string;
-    token: string;
-    endpointKey: string;
-    ws: WebSocket;
-    pending: Map<string, {
-        sessionId: string;
-        actionId: string;
-    }>;
-    /** True once the server advertised the `client_ping_pong` capability. */
-    capable: boolean;
-    /** Timestamp (via opts.now) of the last received pong; seeds the TTL window. */
-    lastPongAt: number;
-    /** Nonce of the most recent in-flight ping, if any. */
-    awaitingNonce: string | undefined;
-    /** Per-session liveness interval handle (only set for capable sessions). */
-    pingTimer: ReturnType<typeof setInterval> | undefined;
-}
-export declare class TelegramNotificationDaemon {
-    private readonly opts;
-    readonly aliasTable: AliasTable;
-    readonly messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
-    /** Telegram message id backing each streamed `${sessionId}:${coalesceKey}`, for in-place edits. */
-    private readonly liveMessages;
-    readonly sessions: Map<string, SessionSocket>;
-    private readonly runtime;
-    private readonly sessionRouter;
-    private readonly pollConflictBackoff;
-    private readonly loopBackoff;
-    private running;
-    private readonly fsImpl;
-    private readonly botApi;
-    private readonly topics;
-    /** Serializes registry snapshots so an older atomic write cannot overwrite newer rename state. */
-    private topicsPersistQueue;
-    /** Daemon edit attempts that can race an accepted user service message. */
-    private readonly daemonRenameAttempts;
-    private readonly selectedAckPending;
-    private readonly pool;
-    private readonly poller;
-    private readonly dispatchState;
-    /** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
-    private readonly replyStore;
-    /** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
-    private readonly draftStream;
-    /** Identity-bearing sessions by repo/branch surface, used to avoid transient duplicate topics. */
-    private readonly topicOwnerByIdentity;
-    /** Non-identity frames held until identity creates the correct thread. */
-    private readonly pendingThreadedFrames;
-    /** Endpoint generation tombstones for sessions that already sent session_closed. */
-    private readonly closedEndpointKeys;
-    /** True once the daemon has nudged the user to enable Threaded Mode. */
-    private threadedFallbackNoticeSent;
-    /** Sessions whose identity header was already sent flat (Threaded Mode off). */
-    private readonly flatIdentitySent;
-    /** Cached result of whether the paired chat is a private chat (flat-fallback gate). */
-    private pairedChatPrivate;
-    /** Bot username from getMe, cached once at owner startup for group/forum command targeting. */
-    private botUsername;
-    /** Sessions whose agent loop is currently busy (drives the typing indicator). */
-    private get busy();
-    /** Inbound update id → originating Telegram message, for delivery reactions. */
-    private get inboundReactions();
-    /**
-     * The owner-bound session-lifecycle control server (create/close/resume).
-     * Started in {@link run} after ownership is confirmed (so exactly one owner
-     * ever runs one), stopped in run()'s finally on any exit path.
-     */
-    private controlServer;
-    /** True while lifecycle control is active, so the loop keeps polling at idle. */
-    private lifecycleControlActive;
-    /** Control token (in-memory) the loopback client presents; never persisted/logged. */
-    private controlToken;
-    /** Loopback WS client to the daemon's own control endpoint (Option A real wire path). */
-    private controlClient;
-    /** Pending lifecycle responses awaiting a control-endpoint reply, by requestId. */
-    private readonly pendingLifecycle;
-    /** Monotonic counter for unique lifecycle request ids. */
-    private lifecycleSeq;
-    /** Attempt tombstones live for the daemon lifetime so a commit key can never send twice. */
-    private readonly selectedAckCache;
-    private cacheSelectedAck;
-    private getCachedSelectedAck;
-    private finishSelectedAck;
-    /**
-     * Cooperatively stop the daemon: set the stop flag and abort the in-flight
-     * long poll so the run loop wakes immediately instead of waiting out the
-     * ~25s getUpdates timeout. Safe to call from a signal handler.
-     */
-    requestStop(_reason?: "reload" | "stop" | "signal"): void;
-    /**
-     * Start the owner-bound lifecycle control server and wire it to the
-     * orchestrator. Called from {@link run} ONLY after ownership is confirmed, so
-     * exactly one owner ever starts exactly one control server (no second poller
-     * / 409). A control-server failure degrades gracefully: the daemon keeps
-     * serving notifications without lifecycle control. Returns true when started.
-     */
-    private startLifecycleControl;
-    /** Stop the lifecycle control server (idempotent); called from run()'s finally. */
-    private stopLifecycleControl;
-    /**
-     * Connect the loopback control client and resolve responses by requestId.
-     * Resolves true once the socket is OPEN (bounded), false on error/timeout, so
-     * the caller only marks lifecycle control active when commands can be sent.
-     */
-    private connectControlClient;
-    /** Send a lifecycle frame over the loopback client and await the response. */
-    private submitLifecycleFrame;
-    private nextLifecycleRequestId;
-    /** Build an authenticated lifecycle frame from a parsed command + identity. */
-    private buildLifecycleFrame;
-    /**
-     * Handle a paired-chat /session_* command: validate (shared validator),
-     * route to the control endpoint, and reply with the outcome. Returns true
-     * when the message was a lifecycle command (so the caller stops processing).
-     */
-    private handleLifecycleCommand;
-    private refreshBotIdentity;
-    /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
-    private formatLifecycleResponse;
-    constructor(opts: TelegramDaemonOptions);
-    private createSessionRouter;
-    loadAliases(): Promise<void>;
-    persistAliases(): Promise<void>;
-    loadSeenUpdateIds(): Promise<void>;
-    persistSeenUpdateIds(): Promise<void>;
-    private pruneSeenUpdateIds;
-    private rememberSeenUpdateId;
-    scanRoots(): Promise<void>;
-    connectSession(sessionId: string, url: string, token: string): void;
-    /**
-     * Start ack-based liveness for a session whose server advertised the
-     * `client_ping_pong` capability. Each interval drops the session when no pong
-     * has arrived within the TTL (the half-open case the socket never signals via
-     * `close`), otherwise sends a fresh application-level ping. The timer is bound
-     * to this exact session object.
-     */
-    private startLiveness;
-    /**
-     * Idempotent, identity-guarded session teardown. Clears the liveness timer,
-     * removes the map entry only when it still points at this exact session object
-     * (so a delayed old close cannot delete a replacement), and best-effort closes
-     * the socket. `scanRoots()` then reconnects the session.
-     */
-    private dropSession;
-    private deleteMessageRoutes;
-    private static readonly THREADED_FRAMES;
-    private topicNameFor;
-    /**
-     * Render the operator-configured topic name template, or `undefined` when no
-     * usable template applies so the caller uses the built-in composition. The
-     * template is honored only if it is non-blank AND every placeholder it
-     * references (`{repo}`, `{branch}`, `{title}`) has a value for this session,
-     * which preserves the default title/repo/branch fallbacks and prevents
-     * half-filled names with dangling separators. Unknown placeholders are left
-     * verbatim.
-     */
-    private renderTopicNameTemplate;
-    private topicIdentityKey;
-    private topicIdentityBase;
-    private topicOwnerForIdentity;
-    private sessionCanClaimIdentity;
-    private submitThreadedFrame;
-    private existingTopicForPrivateChat;
-    /** Best-effort re-assertion for a durable user-owned topic name. */
-    private reconcileUserTopicName;
-    private rememberPendingThreadedFrame;
-    private flushPendingThreadedFrames;
-    /**
-     * Resolve (creating once via `createForumTopic`) the forum topic for a
-     * session. On capability failure (e.g. Threaded Mode off) this returns
-     * `undefined`; callers then flat-deliver to a private paired chat (with a
-     * one-time nudge) or drop fail-closed for a non-private chat.
-     */
-    private ensureTopic;
-    private topicPastOrphanGrace;
-    private deleteOrphanedTopic;
-    /** Best-effort delete of a session topic once its local notification endpoint shuts down. */
-    private deleteTopic;
-    private persistTopics;
-    loadTopics(): Promise<void>;
-    /** Download a Telegram file by its file_path (from getFile) into memory. */
-    private downloadTelegramFile;
-    /**
-     * Per-session private temp directories (mode 0700) holding inbound non-image
-     * attachments. Keyed by session id and reused across transient reconnects;
-     * removed when the daemon stops (see {@link cleanupAllAttachmentDirs}).
-     */
-    private readonly attachmentDirs;
-    /** Lazily create a private, unguessable 0700 temp dir for `sessionId`. */
-    private ensureAttachmentDir;
-    /** Remove all per-session attachment directories. Called on daemon shutdown. */
-    private cleanupAllAttachmentDirs;
-    /**
-     * Resolve an inbound attachment to inline image bytes (forwarded as images) or
-     * a securely-saved file path note (non-images). Non-image bytes are written
-     * into a private per-session temp dir (0700) under an unguessable name via an
-     * exclusive 0600 create (`wx`), so the files are not world-readable and the
-     * write never follows a pre-existing symlink. The directory is removed when the
-     * daemon stops. Returns base64 images to inline plus human-readable file notes
-     * to append to the injected text.
-     */
-    private resolveInboundAttachment;
-    /**
-     * Serialize all pool flushes. Every caller (`submitThreadedFrame`, the flat
-     * fallback, the drain timer's `void this.flushPool()`, topic teardown) goes
-     * through one promise chain, so two flushes never interleave — a live send can
-     * never be in-flight while a finalized flush reads `liveMessages` and decides
-     * to post a fresh (duplicate) final. Errors are swallowed so one failed flush
-     * never poisons the queue (each flush is already best-effort internally).
-     */
-    private flushChain;
-    private flushPool;
-    /** Drain the shared rate-limit pool and deliver each granted send to its topic. */
-    private flushPoolInner;
-    /**
-     * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
-     * so later live/finalized frames edit it in place. Evicts this session's stale
-     * same-category entries (e.g. prior turns) so the map stays bounded.
-     */
-    private recordLiveMessage;
-    /**
-     * Threaded Mode is unavailable (the bot owner has not enabled forum topics in
-     * @BotFather, so `createForumTopic` fails). Deliver the rendered frame flat to
-     * the paired chat instead of dropping it, and nudge the user once. Flat delivery
-     * is gated on the paired chat being a private chat: for a group/supergroup/channel
-     * (e.g. a legacy or hand-edited `chatId`) we keep dropping fail-closed so session
-     * content never lands in a shared chat. Identity headers are sent at most once per
-     * session in flat mode.
-     */
-    private deliverFlatFallback;
-    /**
-     * Resolve (and cache definitive resolution of) whether the paired `chatId` is
-     * a private chat. Topic and flat delivery are only safe in a private DM; an
-     * indeterminate `getChat` result fails closed for this attempt and is retried
-     * later.
-     */
-    private resolvePairedChatPrivacy;
-    /** Keep existing outbound callers fail-closed for indeterminate privacy. */
-    private pairedChatIsPrivate;
-    /** Tell the user once (per daemon run) how to enable Threaded Mode. */
-    private notifyThreadedFallback;
-    private startFlushTimer;
-    private stopFlushTimer;
-    /** Run a root scan, guarding against overlapping scans from the timer + loop. */
-    private runScan;
-    private startScanTimer;
-    private stopScanTimer;
-    /** Send a single `typing` chat action into a busy session's topic (best-effort). */
-    private sendTyping;
-    /** Set a native reaction on an inbound thread message (best-effort). */
-    private setReaction;
-    private startTypingTimer;
-    private stopTypingTimer;
-    handleSessionMessage(session: SessionSocket, msg: any): Promise<void>;
-    private answerCallbackQueryBestEffort;
-    private sendStaleGuidance;
-    /** Consume Telegram forum-topic rename service messages before text routing. */
-    private handleForumTopicEdited;
-    private processTelegramUpdate;
-    handleTelegramUpdate(update: unknown): Promise<void>;
-    pollOnce(signal?: AbortSignal): Promise<number>;
-    /** Sync the bot's Telegram command menu to what the daemon actually handles. */
-    registerBotCommands(): Promise<void>;
-    run(): Promise<void>;
-    /** True when a signal-driven stop or an owner-scoped control request asks the loop to exit. */
-    private controlStopRequested;
-}