agent-afk 5.1.0 → 5.3.0

package/dist/skills/mint/state-store.d.ts

@@ -0,0 +1,4 @@
+import type { MintState } from './index.js';
+export declare function saveMintState(sessionId: string, state: MintState): void;
+export declare function loadMintState(sessionId: string): MintState | null;
+export declare function clearMintState(sessionId: string): void;

package/dist/skills/score/digest-keyboard.d.ts

@@ -0,0 +1,2 @@
+import type { InlineKeyboardMarkup } from 'telegraf/types';
+export declare function buildFarmDigestKeyboard(taskSlug: string): InlineKeyboardMarkup;

package/dist/skills/score/digest.d.ts

@@ -0,0 +1,10 @@
+import { type FarmRunRecord, type FarmBranchRecord } from './farm-run-record.js';
+export type { FarmRunRecord, FarmBranchRecord };
+export declare function formatFarmDigest(record: FarmRunRecord): string;
+export declare function sendFarmDigest(record: FarmRunRecord, opts?: {
+    _push?: typeof import('../../telegram/push.js').pushIfConfigured;
+}): Promise<{
+    sent: boolean;
+    chatCount?: number;
+    reason?: string;
+}>;

package/dist/skills/score/farm-run-record.d.ts

@@ -0,0 +1,20 @@
+import type { BranchScore } from './index.js';
+export interface FarmBranchRecord {
+    index: number;
+    branch: string;
+    label?: string;
+    ok: boolean;
+    commitCount: number;
+    error?: string;
+    score?: BranchScore | null;
+}
+export interface FarmRunRecord {
+    taskName: string;
+    taskSlug: string;
+    baseSha: string;
+    startedAt: string;
+    completedAt: string;
+    branches: FarmBranchRecord[];
+    winner?: number;
+    human_decision?: 'approved' | 'rejected' | 'edited_then_merged';
+}

package/dist/skills/score/index.d.ts

@@ -0,0 +1,33 @@
+import { spawn } from 'child_process';
+export declare const SCORE_SCHEMA_VERSION: 1;
+export declare const DEFAULT_TIMEOUT_MS = 120000;
+export interface BranchScore {
+    schemaVersion: typeof SCORE_SCHEMA_VERSION;
+    pass: number;
+    fail: number;
+    loc_delta: number;
+    lint_ok: boolean | null;
+    duration_ms: number;
+    error?: string;
+    testCmd?: string;
+    branchPath: string;
+    baseSha: string;
+    scoredAt: string;
+}
+export interface ScoreBranchOptions {
+    branchPath: string;
+    baseSha: string;
+    testCmd?: string;
+    timeoutMs?: number;
+    _spawn?: typeof spawn;
+    _readPackageJson?: (path: string) => Promise<unknown>;
+    _now?: () => number;
+    _nowIso?: () => string;
+}
+export interface RankableBranch {
+    index: number;
+    score: BranchScore | null;
+}
+export declare function scoreBranch(opts: ScoreBranchOptions): Promise<BranchScore>;
+export declare function writeScore(farmDir: string, index: number, score: BranchScore): Promise<string>;
+export declare function rankBranches(branches: RankableBranch[]): number[];

package/dist/skills/score/memory-write.d.ts

@@ -0,0 +1,31 @@
+import { type FarmRunRecord, type FarmBranchRecord } from './farm-run-record.js';
+export type { FarmRunRecord, FarmBranchRecord };
+export interface IMemoryStore {
+    storeFact(fact: {
+        session_id?: string;
+        category: 'preference' | 'convention' | 'decision' | 'learning';
+        content: string;
+        source_surface: string;
+    }): number;
+}
+export declare function writeFarmFact(record: FarmRunRecord, opts?: {
+    _store?: IMemoryStore;
+}): {
+    factId: number;
+} | {
+    skipped: true;
+    reason: string;
+};
+export declare function writeFarmDecisionFact(args: {
+    taskSlug: string;
+    decision: NonNullable<FarmRunRecord['human_decision']>;
+    decidedAt: string;
+    via: 'telegram' | 'cli';
+}, opts?: {
+    _store?: IMemoryStore;
+}): {
+    factId: number;
+} | {
+    skipped: true;
+    reason: string;
+};

package/dist/skills/score/winner.d.ts

@@ -0,0 +1,10 @@
+import type { BranchScore } from './index.js';
+import type { CreatedBranch, FarmManifest } from '../../agent/worktree.js';
+export interface WinnerResolution {
+    branch: CreatedBranch;
+    source: 'winner' | 'top-scored' | 'fallback-first-branch';
+}
+export interface ResolveWinnerDeps {
+    loadScore?: (farmDir: string, index: number) => Promise<BranchScore | null>;
+}
+export declare function resolveWinnerBranch(manifest: FarmManifest, deps?: ResolveWinnerDeps): Promise<WinnerResolution>;

package/dist/skills/service-setup/index.d.ts

@@ -0,0 +1,2 @@
+import { type SkillMetadata } from '../index.js';
+export declare const serviceSetupSkill: SkillMetadata;

package/dist/skills/telegram-setup/index.d.ts

@@ -0,0 +1,2 @@
+import { type SkillMetadata } from '../index.js';
+export declare const telegramSetupSkill: SkillMetadata;

package/dist/skills/user-skills.d.ts

@@ -0,0 +1,9 @@
+export declare function validateSkillName(name: string, dirname: string): {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+};
+export type SkillScanOrigin = 'user' | 'project' | `imported:${string}`;
+export declare function scanSkillsFromDir(dir: string, origin: SkillScanOrigin): number;
+export declare function scanAndRegisterUserSkills(): number;

package/dist/telegram/allowlist.d.ts

@@ -0,0 +1,4 @@
+import type { Context, MiddlewareFn } from 'telegraf';
+export type LogFn = (...args: unknown[]) => void;
+export declare function parseAllowedChatIds(raw: string | undefined, log?: LogFn): Set<number>;
+export declare function createAllowlistMiddleware(allowedIds: Set<number>, log?: LogFn): MiddlewareFn<Context>;

package/dist/telegram/bot.d.ts

@@ -0,0 +1,38 @@
+import { Context } from 'telegraf';
+import { SessionManagerOptions } from './session-manager.js';
+export interface BotOptions extends SessionManagerOptions {
+    botToken: string;
+    verbose?: boolean;
+    allowedChatIds: Set<number>;
+}
+export declare class TelegramBot {
+    private bot;
+    private sessionManager;
+    private options;
+    private running;
+    private registeredCommandChats;
+    private messageHandler;
+    private watchManager;
+    private autoSubscribeInterval;
+    private static readonly AUTO_SUBSCRIBE_INTERVAL_MS;
+    constructor(options: BotOptions);
+    private setupHandlers;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStats(): {
+        running: boolean;
+        activeSessions: number;
+        totalChats: number;
+    };
+    getBusySessionCount(): number;
+    handleStart(ctx: Context): Promise<void>;
+    handleHelp(ctx: Context): Promise<void>;
+    handleClear(ctx: Context): Promise<void>;
+    handleMessage(ctx: Context): Promise<void>;
+    handlePhoto(ctx: Context): Promise<void>;
+    handleModelSwitch(ctx: Context): Promise<void>;
+    private startAutoSubscribe;
+    private stopAutoSubscribe;
+    private runAutoSubscribeTick;
+    private log;
+}

package/dist/telegram/construct-session.d.ts

@@ -0,0 +1,11 @@
+import { AgentSession } from '../agent/session.js';
+import type { AgentConfig } from '../agent/types.js';
+import { type CreatedTraceWriter } from '../agent/trace/factory.js';
+import type { TraceWriter } from '../agent/trace/index.js';
+export interface ConstructTelegramSessionDeps {
+    createTraceWriter?: () => CreatedTraceWriter | null;
+    traceWriter?: TraceWriter | null;
+    newSession?: (config: AgentConfig) => AgentSession;
+}
+export declare function createTelegramTraceWriter(factory?: () => CreatedTraceWriter | null): TraceWriter | null;
+export declare function constructTelegramSession(baseConfig: AgentConfig, deps?: ConstructTelegramSessionDeps): AgentSession;

package/dist/telegram/elicitation-callback-data.d.ts

@@ -0,0 +1,11 @@
+export declare const ELICITATION_CALLBACK_PREFIX = "afk:e:";
+export declare const TELEGRAM_CALLBACK_DATA_MAX_BYTES = 64;
+export interface ParsedElicitationCallback {
+    id: string;
+    choiceIndex: number;
+}
+export declare function buildElicitationCallback(id: string, choiceIndex: number): string;
+export declare function parseElicitationCallback(data: string | undefined | null): ParsedElicitationCallback | null;
+export declare const ELICITATION_CUSTOM_CALLBACK_PREFIX = "afk:ec:";
+export declare function buildCustomElicitationCallback(id: string): string;
+export declare function parseCustomElicitationCallback(data: string | undefined | null): string | null;

package/dist/telegram/elicitation-handler.d.ts

@@ -0,0 +1,6 @@
+import { Telegraf } from 'telegraf';
+import type { ElicitationHandler } from '../agent/elicitation-router.js';
+import type { MessageHandler } from './handlers/message.js';
+export declare function makeTelegramElicitationHandler(messageHandler: MessageHandler, bot: Telegraf, chatId: number, opts?: {
+    ledgerOriginated?: boolean;
+}): ElicitationHandler;

package/dist/telegram/elicitation-telegram.d.ts

@@ -0,0 +1,6 @@
+import type { Telegraf } from 'telegraf';
+import type { ElicitationHandler } from '../agent/elicitation-router.js';
+export declare const ELICITATION_CALLBACK_PREFIX = "afk:pa:";
+export declare function createTelegramElicitationHandler(bot: Telegraf, chatIds: Set<number>, log?: (...args: unknown[]) => void): ElicitationHandler;
+export declare function composeTelegramElicitation(askHandler: ElicitationHandler, formHandler: ElicitationHandler): ElicitationHandler;
+export declare function _resetPendingForTests(): void;

package/dist/telegram/error-utils.d.ts

@@ -0,0 +1,5 @@
+import { classifyUsageLimitError } from '../agent/providers/anthropic-direct/usage-limit.js';
+export type { UsageLimitClassification } from '../agent/providers/anthropic-direct/usage-limit.js';
+export declare function isTelegramTransportError(error: unknown): boolean;
+export { classifyUsageLimitError as classifyUsageLimit };
+export { isRateLimitError, isNetworkError } from '../utils/error-classifiers.js';

package/dist/telegram/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/telegram/farm-callback-data.d.ts

@@ -0,0 +1,9 @@
+export declare const FARM_CALLBACK_PREFIX = "afk:f:";
+export declare const TELEGRAM_CALLBACK_DATA_MAX_BYTES = 64;
+export type FarmCallbackAction = 'p' | 'd' | 'r' | 'x';
+export interface ParsedFarmCallback {
+    action: FarmCallbackAction;
+    taskSlug: string;
+}
+export declare function parseFarmCallback(data: string | undefined | null): ParsedFarmCallback | null;
+export declare function buildFarmCallback(action: FarmCallbackAction, taskSlug: string): string;

package/dist/telegram/formatter.d.ts

@@ -0,0 +1,24 @@
+export declare function splitLongMessage(text: string, maxLength?: number): string[];
+export declare function markdownToTelegramHtml(text: string): string;
+export declare function escapeHtml(text: string): string;
+export declare function formatSystemError(code: string, path: string): string;
+export declare function formatQueued(depth: number): string;
+export declare function escapeMarkdown(text: string): string;
+export declare function formatError(error: Error | string): string;
+export declare function formatInternalError(): string;
+export declare function formatHelp(sdkCommands?: string[]): string;
+export declare function formatWelcome(): string;
+export declare function formatModelSwitch(model: string): string;
+export declare function formatClear(): string;
+export declare function formatCwdCurrent(cwd: string | undefined): string;
+export declare function formatCwdSwitch(cwd: string): string;
+export declare function formatNameCurrent(name: string | undefined): string;
+export declare function formatNameInvalid(): string;
+export declare function formatNameSet(name: string, resumeCommand?: string): string;
+export declare function formatReset(): string;
+export declare function formatCompact(opts?: {
+    before: number;
+    after: number;
+    tokensSavedEstimate?: number;
+}): string;
+export declare function formatCompactNoop(reason: string): string;

package/dist/telegram/handlers/commands.d.ts

@@ -0,0 +1,11 @@
+import { Context } from 'telegraf';
+import { SessionManager } from '../session-manager.js';
+type LogFn = (...args: unknown[]) => void;
+export declare const MODEL_ALIASES_HINT: readonly ["local", "small", "medium", "large", "opus", "opus_1m", "sonnet", "sonnet_1m", "haiku", "fable"];
+export declare function handleClear(ctx: Context, sessionManager: SessionManager, registeredCommandChats: Set<number>, log: LogFn): Promise<void>;
+export declare function handleCompact(ctx: Context, sessionManager: SessionManager, log: LogFn): Promise<void>;
+export declare function handleModelSwitch(ctx: Context, sessionManager: SessionManager, log: LogFn): Promise<void>;
+export declare function resolveCwdInput(input: string, base: string): string;
+export declare function handleCwd(ctx: Context, sessionManager: SessionManager, log: LogFn): Promise<void>;
+export declare function handleName(ctx: Context, sessionManager: SessionManager, log: LogFn): Promise<void>;
+export {};

package/dist/telegram/handlers/farm-callbacks.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from 'telegraf';
+import { loadFarm, recordHumanDecision, recordPrCreated, recordRespawn } from '../../agent/worktree.js';
+import { checkGhReady, type CreatePrOpts, type ExecFn, type GhReadiness } from '../../agent/gh.js';
+import { writeFarmDecisionFact } from '../../skills/score/memory-write.js';
+import { resolveWinnerBranch } from '../../skills/score/winner.js';
+type LogFn = (...args: unknown[]) => void;
+export interface FarmCallbackDeps {
+    loadFarm?: typeof loadFarm;
+    recordHumanDecision?: typeof recordHumanDecision;
+    writeFarmDecisionFact?: typeof writeFarmDecisionFact;
+    resolveWinnerBranch?: typeof resolveWinnerBranch;
+    execGit?: (cwd: string, args: string[]) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    log?: LogFn;
+    recordRespawn?: typeof recordRespawn;
+    spawnFarm?: (args: string[]) => void;
+    _now?: () => Date;
+    _randomSuffix?: () => string;
+    checkGhReady?: (opts?: Parameters<typeof checkGhReady>[0]) => Promise<GhReadiness>;
+    createPr?: (opts: CreatePrOpts, execFn?: ExecFn) => Promise<string>;
+    recordPrCreated?: typeof recordPrCreated;
+}
+export declare function handleFarmCallback(ctx: Context, deps?: FarmCallbackDeps): Promise<void>;
+export {};

package/dist/telegram/handlers/help.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'telegraf';
+import { SessionManager } from '../session-manager.js';
+export declare function handleHelp(ctx: Context, sessionManager: SessionManager): Promise<void>;

package/dist/telegram/handlers/message.d.ts

@@ -0,0 +1,26 @@
+import { Context } from 'telegraf';
+import { Telegraf } from 'telegraf';
+import { SessionManager } from '../session-manager.js';
+type LogFn = (...args: unknown[]) => void;
+export declare class MessageHandler {
+    private static readonly MAX_QUEUE_DEPTH;
+    private sessionManager;
+    private messageQueues;
+    private registeredCommandChats;
+    private log;
+    private bot;
+    pendingElicitations: Map<number, (text: string) => void>;
+    ledgerOriginatedPendingChats: Set<number>;
+    constructor(bot: Telegraf, sessionManager: SessionManager, registeredCommandChats: Set<number>, log: LogFn);
+    handlePhoto(ctx: Context): Promise<void>;
+    handle(ctx: Context): Promise<void>;
+    processClearDirect(chatId: number, ctx: Context): Promise<void>;
+    private processCompactDirect;
+    private enqueueMessage;
+    private enqueuePhoto;
+    enqueueClear(chatId: number, ctx: Context): void;
+    enqueueCompact(chatId: number, ctx: Context): void;
+    private processOne;
+    drainQueue(chatId: number): Promise<void>;
+}
+export {};

package/dist/telegram/handlers/registration.d.ts

@@ -0,0 +1,5 @@
+import { Telegraf } from 'telegraf';
+import type { IAgentSession } from '../../agent/types.js';
+type LogFn = (...args: unknown[]) => void;
+export declare function registerChatCommands(bot: Telegraf, chatId: number, session: IAgentSession, registeredCommandChats: Set<number>, log: LogFn): Promise<void>;
+export {};

package/dist/telegram/handlers/start.d.ts

@@ -0,0 +1,2 @@
+import { Context } from 'telegraf';
+export declare function handleStart(ctx: Context): Promise<void>;

package/dist/telegram/index.d.ts

@@ -0,0 +1,8 @@
+export { TelegramBot } from './bot.js';
+export type { BotOptions } from './bot.js';
+export { SessionManager } from './session-manager.js';
+export type { SessionManagerOptions } from './session-manager.js';
+export { splitLongMessage, escapeMarkdown, formatError, formatWelcome, formatModelSwitch, formatClear, formatReset, formatCompact, formatCompactNoop, } from './formatter.js';
+export { isRateLimitError, isNetworkError } from './error-utils.js';
+export { streamResponse } from './streaming.js';
+export { parseAllowedChatIds, createAllowlistMiddleware } from './allowlist.js';

package/dist/telegram/manager.d.ts

@@ -0,0 +1,35 @@
+export interface ManagerPaths {
+    pidFile: string;
+    logFile: string;
+}
+export declare function getManagerPaths(): ManagerPaths;
+export interface BotStatus {
+    running: boolean;
+    pid?: number;
+    uptimeSec?: number;
+    memoryMb?: number;
+    logTail?: string[];
+    pidFile: string;
+    logFile: string;
+}
+export interface StartResult {
+    kind: 'started';
+    pid: number;
+    logFile: string;
+}
+export interface StartFailure {
+    kind: 'already-running' | 'exited-immediately' | 'spawn-failed';
+    pid?: number;
+    logTail?: string[];
+    message: string;
+}
+export interface StopResult {
+    kind: 'stopped' | 'not-running' | 'force-killed';
+    pid?: number;
+}
+export declare function isRunning(pidFile: string): number | null;
+export declare function resolveEntrypoint(searchDir?: string, existsCheck?: (path: string) => boolean): string;
+export declare function start(): Promise<StartResult | StartFailure>;
+export declare function stop(): Promise<StopResult>;
+export declare function status(): BotStatus;
+export declare function parseEtime(etime: string): number | undefined;

package/dist/telegram/mcp-session.d.ts

@@ -0,0 +1,8 @@
+import type { IAgentSession } from '../agent/types.js';
+import { McpManager } from '../agent/mcp/index.js';
+import type { TraceWriter } from '../agent/trace/index.js';
+export interface LoadTelegramMcpManagerOptions {
+    traceWriter?: TraceWriter;
+}
+export declare function loadTelegramMcpManager(cwd: string | undefined, opts?: LoadTelegramMcpManagerOptions): Promise<McpManager | undefined>;
+export declare function attachMcpCleanup<T extends IAgentSession>(session: T, mcpManager: McpManager | undefined): T;

package/dist/telegram/notify-routing.d.ts

@@ -0,0 +1,12 @@
+export type NotifyMode = 'primary' | 'broadcast' | 'custom';
+export interface TelegramNotifyConfig {
+    mode?: NotifyMode;
+    primaryChatId?: number;
+    targets?: number[];
+}
+export declare function resolvePrimaryChatId(allowed: readonly number[], explicit?: number): number | undefined;
+export declare function resolveNotifyTargets(allowlist: Set<number>, config?: TelegramNotifyConfig): number[];
+export declare function parseChatId(raw: string | undefined): number | undefined;
+export declare function parseMode(raw: string | undefined): NotifyMode | undefined;
+export declare function loadNotifyConfig(): TelegramNotifyConfig;
+export declare function resolveConfiguredNotifyTargets(): number[];

package/dist/telegram/push.d.ts

@@ -0,0 +1,23 @@
+import type { InlineKeyboardMarkup } from 'telegraf/types';
+export interface PushOptions {
+    token: string;
+    chatId: string | number;
+    text: string;
+    parseMode?: 'MarkdownV2' | 'HTML' | 'Markdown';
+    replyMarkup?: InlineKeyboardMarkup;
+    fetchImpl?: typeof fetch;
+    apiBase?: string;
+}
+export interface PushResult {
+    ok: boolean;
+    status: number;
+    errorMessage?: string;
+}
+export declare function push(options: PushOptions): Promise<PushResult>;
+export declare function pushMarkdown(options: Omit<PushOptions, 'parseMode'>): Promise<PushResult>;
+export declare function pushIfConfigured(text: string, opts?: {
+    parseMode?: PushOptions['parseMode'];
+    markdown?: boolean;
+    replyMarkup?: PushOptions['replyMarkup'];
+    fetchImpl?: typeof fetch;
+}): Promise<PushResult[] | null>;

package/dist/telegram/session-manager.d.ts

@@ -0,0 +1,42 @@
+import type { IAgentSession, AgentConfig, AgentModelInput, ThinkingConfig, EffortLevel, ResponseMetadata } from '../agent/types.js';
+export interface SessionManagerOptions {
+    dataDir?: string;
+    defaultModel?: AgentModelInput;
+    apiKey: string;
+    settingSources?: ('user' | 'project')[];
+    thinking?: ThinkingConfig;
+    effort?: EffortLevel;
+    botCwd?: string;
+    createSession: (config: AgentConfig) => Promise<IAgentSession>;
+}
+export declare class SessionManager {
+    private sessions;
+    private pendingSessions;
+    private sessionData;
+    private sessionStats;
+    private autosaveFailureLogged;
+    private options;
+    constructor(options: SessionManagerOptions);
+    getSessionIfExists(chatId: number): IAgentSession | undefined;
+    getSession(chatId: number): Promise<IAgentSession>;
+    private _touchActivity;
+    recordTelegramTurn(chatId: number, userText: string, assistantText: string, metadata?: ResponseMetadata): void;
+    private _hydrateStatsFromStore;
+    getSessionName(chatId: number): string | undefined;
+    setSessionName(chatId: number, slug: string): {
+        persisted: boolean;
+    };
+    private _getOrCreateStats;
+    private _resetStats;
+    resetSession(chatId: number): Promise<void>;
+    switchModel(chatId: number, model: AgentModelInput): Promise<void>;
+    getModel(chatId: number): AgentModelInput;
+    setCwd(chatId: number, cwd: string): Promise<void>;
+    getCwd(chatId: number): string | undefined;
+    loadSessions(): Promise<void>;
+    saveSessions(): Promise<void>;
+    closeAll(): Promise<void>;
+    getSessionCount(): number;
+    getChatCount(): number;
+    getBusySessionCount(): number;
+}

package/dist/telegram/setup-wizard.d.ts

@@ -0,0 +1,59 @@
+export declare function readEnvVarFromFile(filePath: string, key: string): string | undefined;
+export interface CheckTokenResult {
+    set: boolean;
+    valid: boolean;
+    username?: string;
+    botId?: number;
+    reason?: string;
+}
+export declare function checkTokenFromFile(filePath: string): Promise<CheckTokenResult>;
+export interface DiscoverChatResult {
+    found: boolean;
+    chats: DiscoveredChat[];
+    reason?: string;
+}
+export declare function discoverChatFromFile(filePath: string, opts?: {
+    timeoutSec?: number;
+}): Promise<DiscoverChatResult>;
+export interface BotIdentity {
+    id: number;
+    username?: string;
+    firstName: string;
+}
+export declare function validateBotToken(token: string): Promise<BotIdentity | null>;
+interface UpdateEntry {
+    message?: {
+        chat?: {
+            id?: number;
+            type?: string;
+            username?: string;
+            first_name?: string;
+        };
+    };
+    edited_message?: {
+        chat?: {
+            id?: number;
+            type?: string;
+            username?: string;
+            first_name?: string;
+        };
+    };
+}
+export interface DiscoveredChat {
+    chatId: number;
+    type: string;
+    username?: string;
+    firstName?: string;
+}
+export declare function findChatIdInUpdates(updates: UpdateEntry[]): DiscoveredChat[];
+export declare function fetchUpdates(token: string): Promise<UpdateEntry[]>;
+export declare function pollForChats(token: string, opts?: {
+    maxAttempts?: number;
+    intervalMs?: number;
+}): Promise<DiscoveredChat[]>;
+export declare function runTelegramSetup(): Promise<{
+    envPath: string;
+    bot: BotIdentity;
+    chatId: number;
+}>;
+export {};

package/dist/telegram/stream-timeout-error.d.ts

@@ -0,0 +1,3 @@
+export declare class StreamTimeoutError extends Error {
+    constructor(message: string);
+}

package/dist/telegram/streaming.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from 'telegraf';
+import { StreamTimeoutError } from './stream-timeout-error.js';
+import type { IAgentSession, ResponseMetadata } from '../agent/types.js';
+import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
+export { StreamTimeoutError };
+export declare function renderSubagentFooter(steps: number, recent: readonly string[]): string;
+export declare function streamResponse(ctx: Context, session: IAgentSession, content: string | ContentBlockParam[], logger?: (...args: unknown[]) => void, options?: {
+    cleanFinal?: boolean;
+    onComplete?: (assistantText: string, metadata?: ResponseMetadata) => void | Promise<void>;
+}): Promise<void>;

package/dist/telegram/version-check.d.ts

@@ -0,0 +1,19 @@
+export interface VersionDriftResult {
+    drift: boolean;
+    message?: string;
+}
+export declare function checkVersionDrift(spawnedVersion: string, diskVersion: string): VersionDriftResult;
+export declare const MAX_DRIFT_DEFERRALS = 12;
+export type VersionDriftAction = 'none' | 'exit' | 'defer' | 'force-exit';
+export interface VersionDriftDecisionInput {
+    drift: VersionDriftResult;
+    busyCount: number;
+    deferrals: number;
+    maxDeferrals?: number;
+}
+export interface VersionDriftDecision {
+    action: VersionDriftAction;
+    deferrals: number;
+    message?: string;
+}
+export declare function decideVersionDriftAction(input: VersionDriftDecisionInput): VersionDriftDecision;

package/dist/telegram/watch.d.ts

@@ -0,0 +1,22 @@
+import { type LedgerRecord } from '../agent/session-ledger.js';
+import type { MessageHandler } from './handlers/message.js';
+import type { Telegraf } from 'telegraf';
+type SendFn = (text: string) => Promise<void>;
+type LogFn = (...args: unknown[]) => void;
+export declare function renderLedgerRecord(rec: LedgerRecord): string | null;
+export declare function resolveWatchTarget(input: string): Promise<string | null>;
+export declare function listWatchableSessions(): Promise<string>;
+export declare class SessionWatchManager {
+    private readonly watches;
+    private readonly log;
+    private readonly bot;
+    private readonly messageHandler;
+    constructor(log?: LogFn, bot?: Telegraf, messageHandler?: MessageHandler);
+    watching(chatId: number): string | undefined;
+    getWatched(chatId: number): string | undefined;
+    start(chatId: number, sessionId: string, send: SendFn): void;
+    stop(chatId: number): string | undefined;
+    stopAll(): Promise<void>;
+    private _run;
+}
+export {};

package/dist/telegram.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};