@sayknow-cli/coding-agent 0.3.11 → 0.3.13

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

@@ -1,429 +0,0 @@
-import * as fs from "node:fs";
-import type { Settings } from "../config/settings";
-import type { DaemonRuntimeInfo } from "../daemon/control-types";
-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;
-    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;
-}
-export declare const HEARTBEAT_INTERVAL_MS = 5000;
-export declare const HEARTBEAT_TTL_MS = 20000;
-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 = 2;
-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";
-}>;
-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[];
-}
-/**
- * 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;
-    }): 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;
-    }): Promise<unknown>;
-}
-export interface TelegramUpdatePollerOptions {
-    botApi: BotApi;
-    runtime: NotificationOperatorRuntime;
-    backoff: OperatorBackoffPolicy;
-    processUpdate: (update: unknown) => Promise<void>;
-}
-/** 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;
-    };
-}
-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;
-    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;
-    /**
-     * 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;
-    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;
-    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;
-    private topicIdentityKey;
-    private topicIdentityBase;
-    private topicOwnerForIdentity;
-    private sessionCanClaimIdentity;
-    private submitThreadedFrame;
-    private existingTopicForPrivateChat;
-    private rememberPendingThreadedFrame;
-    private flushPendingThreadedFrames;
-    private ensureTopic;
-    private deleteTopic;
-    private persistTopics;
-    loadTopics(): Promise<void>;
-    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;
-    private ensureAttachmentDir;
-    private cleanupAllAttachmentDirs;
-    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;
-    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;
-    private deliverFlatFallback;
-    private pairedChatIsPrivate;
-    private notifyThreadedFallback;
-    private startFlushTimer;
-    private stopFlushTimer;
-    private runScan;
-    private startScanTimer;
-    private stopScanTimer;
-    private sendTyping;
-    private setReaction;
-    private startTypingTimer;
-    private stopTypingTimer;
-    handleSessionMessage(session: SessionSocket, msg: any): Promise<void>;
-    private answerCallbackQueryBestEffort;
-    private sendStaleGuidance;
-    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>;
-    private controlStopRequested;
-}

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

@@ -1,119 +0,0 @@
-/**
- * Telegram **reference** client for the notifications SDK.
- *
- * This is an example/template, NOT an upstream-owned integration: it implements
- * the documented WS protocol (see `docs/notifications-sdk.md`) so you can copy it
- * to build Discord/Slack/etc. clients with zero upstream changes. The Bot API
- * transport shape is salvaged from the removed `telegram-remote` package.
- *
- * Flow: read the endpoint discovery file -> connect to the session WS -> render
- * `action_needed` to a Telegram chat (inline keyboard for options) -> map button
- * taps / text replies to `reply` frames -> reflect `action_resolved` /
- * `reply_rejected`.
- *
- * Dependency-free: uses global `fetch` and `WebSocket` (Bun/Node 22+).
- */
-/** One inline-keyboard button. */
-export interface InlineButton {
-    text: string;
-    callback_data: string;
-}
-/** A rendered Telegram message for an `action_needed`. */
-export interface RenderedMessage {
-    text: string;
-    inline_keyboard?: InlineButton[][];
-}
-type TelegramSend = (method: string, body: unknown) => Promise<Response>;
-/** Encode `actionId` + option `index` into Telegram callback_data (<=64 bytes). */
-export declare function encodeCallbackData(actionId: string, index: number): string;
-/** Decode callback_data produced by {@link encodeCallbackData}. */
-export declare function decodeCallbackData(data: string): {
-    id: string;
-    index: number;
-} | null;
-export interface CallbackRoute {
-    sessionId: string;
-    actionId: string;
-    answer: number | string;
-}
-export interface SerializedAliasTable {
-    version: 1;
-    next: number;
-    routes: Record<string, CallbackRoute>;
-}
-export interface AliasTable {
-    put(route: CallbackRoute): string;
-    get(alias: string): CallbackRoute | undefined;
-    delete(alias: string): boolean;
-    serialize(): SerializedAliasTable;
-    load(json: unknown): void;
-    entries(): Array<[string, CallbackRoute]>;
-}
-/** Create a compact, durable callback alias table. Serialized data contains routing ids only. */
-export declare function createAliasTable(): AliasTable;
-/** Render an `action_needed` payload into a Telegram message. */
-export declare function buildActionMessage(action: {
-    kind: "ask" | "idle";
-    id: string;
-    question?: string;
-    options?: string[];
-    summary?: string;
-}): RenderedMessage;
-/** Render an `action_needed` body as raw markdown (rich-message source; the HTML fallback stays on buildActionMessage). */
-export declare function buildActionMarkdown(action: {
-    kind: "ask" | "idle";
-    question?: string;
-    options?: string[];
-    summary?: string;
-}): string;
-/** Send Telegram HTML text chunks sequentially so long messages preserve order. */
-export declare function sendTelegramHtmlChunks(send: TelegramSend, chatId: string, text: string, inlineKeyboard?: InlineButton[][]): Promise<void>;
-/** A protocol `reply` frame the client should send to the server. */
-export interface ReplyFrame {
-    type: "reply";
-    id: string;
-    answer: number | string;
-    token: string;
-}
-/**
- * Map a Telegram update into a reply frame, given the most recent pending ask id
- * (for free-text replies). Returns `null` when the update is not actionable.
- */
-export declare function telegramUpdateToReply(update: unknown, token: string, latestPendingAskId: string | undefined): ReplyFrame | null;
-export type RouteDecision = ({
-    kind: "reply";
-} & CallbackRoute) | {
-    kind: "stale";
-    reason: string;
-} | {
-    kind: "ignore";
-};
-export interface RouteInboundContext {
-    aliasTable: Pick<AliasTable, "get">;
-    messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
-    pairedChatId: string;
-}
-/** Route a Telegram update to a session/action without I/O. Fail closed under ambiguity. */
-export declare function routeInboundUpdate(update: unknown, ctx: RouteInboundContext): RouteDecision;
-/** Read `{url, token, pid?, stale?}` from an endpoint discovery file. */
-export declare function readEndpoint(path: string): {
-    url: string;
-    token: string;
-    pid?: number;
-    stale?: boolean;
-};
-/** Options for {@link runTelegramReferenceClient}. */
-export interface TelegramReferenceOptions {
-    botToken: string;
-    chatId: string;
-    endpointFile: string;
-    apiBase?: string;
-    fetchImpl?: typeof fetch;
-}
-/**
- * Run the reference bridge until the WebSocket closes. Sends `action_needed` to
- * the chat and forwards taps/text as replies. This is a minimal example loop;
- * production clients add reconnection, multi-chat routing, and persistence.
- */
-export declare function runTelegramReferenceClient(opts: TelegramReferenceOptions): Promise<void>;
-export {};

package/dist/types/notifications/threaded-inbound.d.ts

@@ -1,77 +0,0 @@
-/**
- * Fail-closed routing for inbound Telegram updates in threaded session mode.
- *
- * In the threaded surface, a free-text reply inside a session's forum topic
- * injects a new user turn into that session (steering it at any time). That is
- * remote control of the agent, so every inbound path must fail closed:
- *
- * - the update must come from the single paired chat id;
- * - it must carry a `message_thread_id` (topic) that maps to a KNOWN session;
- * - its `update_id` must not have been seen before (idempotency / replay guard);
- * - the text must be non-empty.
- *
- * Anything ambiguous or unmapped is ignored with a reason rather than guessed.
- * This module is pure (the dedupe set and topic map are injected) so the
- * security rules are exhaustively unit-testable without a live Bot API.
- */
-/** Minimal shape of the inbound Telegram message we route on. */
-export interface InboundUpdate {
-    update_id?: unknown;
-    message?: {
-        message_id?: unknown;
-        text?: unknown;
-        caption?: unknown;
-        photo?: unknown;
-        document?: unknown;
-        video?: unknown;
-        audio?: unknown;
-        voice?: unknown;
-        animation?: unknown;
-        chat?: {
-            id?: unknown;
-        };
-        message_thread_id?: unknown;
-    };
-}
-/** A downloadable media attachment referenced by an inbound message. */
-export interface InboundAttachment {
-    /** Telegram file_id to resolve via getFile. */
-    fileId: string;
-    /** Source media kind; "photo" is always an image. */
-    kind: "photo" | "document" | "video" | "audio" | "voice" | "animation";
-    /** MIME type when Telegram provides one. */
-    mime?: string;
-    /** Original file name when provided. */
-    fileName?: string;
-}
-/** Context for {@link decideThreadedInbound}. All lookups are injected. */
-export interface ThreadedInboundCtx {
-    /** The single paired chat id (string-compared). */
-    pairedChatId: string;
-    /** Resolve a topic/thread id to its owning session id, or undefined. */
-    topicToSession: (threadId: string) => string | undefined;
-    /** Whether this `update_id` has already been processed. */
-    isDuplicate: (updateId: number) => boolean;
-}
-/** Outcome of routing an inbound update. */
-export type ThreadedInboundDecision = {
-    kind: "inject";
-    sessionId: string;
-    text: string;
-    updateId: number;
-    threadId: string;
-    messageId?: number;
-    attachment?: InboundAttachment;
-} | {
-    kind: "duplicate";
-    updateId: number;
-} | {
-    kind: "ignore";
-    reason: string;
-};
-/**
- * Decide whether an inbound update should inject a user turn. Fail-closed:
- * returns `ignore` (with a reason) or `duplicate` for anything that is not an
- * unambiguous, first-seen, paired-chat, known-topic text message.
- */
-export declare function decideThreadedInbound(update: InboundUpdate, ctx: ThreadedInboundCtx): ThreadedInboundDecision;