@openacp/cli 0.6.0 → 0.6.2

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { EventEmitter } from 'node:events';
 import { Readable, Writable } from 'node:stream';
 import { PromptResponse } from '@agentclientprotocol/sdk';
+import * as http from 'node:http';
 
 interface Attachment {
     type: 'image' | 'audio' | 'file';
@@ -10,6 +11,7 @@ interface Attachment {
     fileName: string;
     mimeType: string;
     size: number;
+    originalFilePath?: string;
 }
 interface IncomingMessage {
     channelId: string;
@@ -19,7 +21,7 @@ interface IncomingMessage {
     attachments?: Attachment[];
 }
 interface OutgoingMessage {
-    type: "text" | "thought" | "tool_call" | "tool_update" | "plan" | "usage" | "session_end" | "error" | "attachment";
+    type: "text" | "thought" | "tool_call" | "tool_update" | "plan" | "usage" | "session_end" | "error" | "attachment" | "system_message";
     text: string;
     metadata?: Record<string, unknown>;
     attachment?: Attachment;
@@ -37,7 +39,7 @@ interface PermissionOption {
 interface NotificationMessage {
     sessionId: string;
     sessionName?: string;
-    type: "completed" | "error" | "permission" | "input_required";
+    type: "completed" | "error" | "permission" | "input_required" | "budget_warning";
     summary: string;
     deepLink?: string;
 }
@@ -100,6 +102,9 @@ type AgentEvent = {
 } | {
     type: "error";
     message: string;
+} | {
+    type: "system_message";
+    message: string;
 };
 interface PlanEntry {
     content: string;
@@ -209,6 +214,26 @@ interface TelegramPlatformData {
     topicId: number;
     skillMsgId?: number;
 }
+interface UsageRecord {
+    id: string;
+    sessionId: string;
+    agentName: string;
+    tokensUsed: number;
+    contextSize: number;
+    cost?: {
+        amount: number;
+        currency: string;
+    };
+    timestamp: string;
+}
+interface UsageSummary {
+    period: "today" | "week" | "month" | "all";
+    totalTokens: number;
+    totalCost: number;
+    currency: string;
+    sessionCount: number;
+    recordCount: number;
+}
 interface DiscordPlatformData {
     threadId: string;
     skillMsgId?: string;
@@ -276,6 +301,26 @@ declare const TunnelSchema: z.ZodDefault<z.ZodObject<{
     } | undefined;
 }>>;
 type TunnelConfig = z.infer<typeof TunnelSchema>;
+declare const UsageSchema: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    monthlyBudget: z.ZodOptional<z.ZodNumber>;
+    warningThreshold: z.ZodDefault<z.ZodNumber>;
+    currency: z.ZodDefault<z.ZodString>;
+    retentionDays: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    warningThreshold: number;
+    currency: string;
+    retentionDays: number;
+    monthlyBudget?: number | undefined;
+}, {
+    enabled?: boolean | undefined;
+    monthlyBudget?: number | undefined;
+    warningThreshold?: number | undefined;
+    currency?: string | undefined;
+    retentionDays?: number | undefined;
+}>>;
+type UsageConfig = z.infer<typeof UsageSchema>;
 declare const ConfigSchema: z.ZodObject<{
     channels: z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -300,8 +345,8 @@ declare const ConfigSchema: z.ZodObject<{
     }, {
         command: string;
         args?: string[] | undefined;
-        workingDirectory?: string | undefined;
         env?: Record<string, string> | undefined;
+        workingDirectory?: string | undefined;
     }>>>>;
     defaultAgent: z.ZodString;
     workspace: z.ZodDefault<z.ZodObject<{
@@ -402,6 +447,25 @@ declare const ConfigSchema: z.ZodObject<{
             token?: string | undefined;
         } | undefined;
     }>>;
+    usage: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        monthlyBudget: z.ZodOptional<z.ZodNumber>;
+        warningThreshold: z.ZodDefault<z.ZodNumber>;
+        currency: z.ZodDefault<z.ZodString>;
+        retentionDays: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        warningThreshold: number;
+        currency: string;
+        retentionDays: number;
+        monthlyBudget?: number | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        monthlyBudget?: number | undefined;
+        warningThreshold?: number | undefined;
+        currency?: string | undefined;
+        retentionDays?: number | undefined;
+    }>>;
     integrations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         installed: z.ZodBoolean;
         installedAt: z.ZodOptional<z.ZodString>;
@@ -412,6 +476,88 @@ declare const ConfigSchema: z.ZodObject<{
         installed: boolean;
         installedAt?: string | undefined;
     }>>>;
+    speech: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        stt: z.ZodDefault<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>>>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        }, {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        }>>;
+        tts: z.ZodDefault<z.ZodObject<{
+            provider: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>>>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        }, {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        stt: {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        };
+        tts: {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        };
+    }, {
+        stt?: {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        } | undefined;
+        tts?: {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        } | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     api: {
         port: number;
@@ -460,10 +606,33 @@ declare const ConfigSchema: z.ZodObject<{
     sessionStore: {
         ttlDays: number;
     };
+    usage: {
+        enabled: boolean;
+        warningThreshold: number;
+        currency: string;
+        retentionDays: number;
+        monthlyBudget?: number | undefined;
+    };
     integrations: Record<string, {
         installed: boolean;
         installedAt?: string | undefined;
     }>;
+    speech: {
+        stt: {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        };
+        tts: {
+            provider: string | null;
+            providers: Record<string, z.objectOutputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">>;
+        };
+    };
 }, {
     channels: Record<string, z.objectInputType<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -477,8 +646,8 @@ declare const ConfigSchema: z.ZodObject<{
     agents?: Record<string, {
         command: string;
         args?: string[] | undefined;
-        workingDirectory?: string | undefined;
         env?: Record<string, string> | undefined;
+        workingDirectory?: string | undefined;
     }> | undefined;
     tunnel?: {
         options?: Record<string, unknown> | undefined;
@@ -512,10 +681,33 @@ declare const ConfigSchema: z.ZodObject<{
     sessionStore?: {
         ttlDays?: number | undefined;
     } | undefined;
+    usage?: {
+        enabled?: boolean | undefined;
+        monthlyBudget?: number | undefined;
+        warningThreshold?: number | undefined;
+        currency?: string | undefined;
+        retentionDays?: number | undefined;
+    } | undefined;
     integrations?: Record<string, {
         installed: boolean;
         installedAt?: string | undefined;
     }> | undefined;
+    speech?: {
+        stt?: {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        } | undefined;
+        tts?: {
+            provider?: string | null | undefined;
+            providers?: Record<string, z.objectInputType<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.ZodTypeAny, "passthrough">> | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 type Config = z.infer<typeof ConfigSchema>;
 declare function expandHome(p: string): string;
@@ -575,7 +767,7 @@ interface IChannelAdapter {
  * Adapters can extend this or implement IChannelAdapter directly.
  */
 declare abstract class ChannelAdapter<TCore = unknown> implements IChannelAdapter {
-    protected core: TCore;
+    readonly core: TCore;
     protected config: ChannelConfig;
     constructor(core: TCore, config: ChannelConfig);
     abstract start(): Promise<void>;
@@ -588,6 +780,9 @@ declare abstract class ChannelAdapter<TCore = unknown> implements IChannelAdapte
     deleteSessionThread(_sessionId: string): Promise<void>;
     sendSkillCommands(_sessionId: string, _commands: AgentCommand[]): Promise<void>;
     cleanupSkillCommands(_sessionId: string): Promise<void>;
+    archiveSessionTopic(_sessionId: string): Promise<{
+        newThreadId: string;
+    } | null>;
 }
 
 declare class NotificationManager {
@@ -608,7 +803,45 @@ declare class StderrCapture {
     getLastLines(): string;
 }
 
-declare class AgentInstance {
+/**
+ * A minimal, generic typed event emitter.
+ *
+ * Usage:
+ *   interface MyEvents {
+ *     data: (payload: string) => void
+ *     error: (err: Error) => void
+ *   }
+ *   const emitter = new TypedEmitter<MyEvents>()
+ *   emitter.on('data', (payload) => { ... })
+ *   emitter.emit('data', 'hello')
+ */
+declare class TypedEmitter<T extends Record<string & keyof T, (...args: any[]) => void>> {
+    private listeners;
+    private paused;
+    private buffer;
+    on<K extends keyof T>(event: K, listener: T[K]): this;
+    off<K extends keyof T>(event: K, listener: T[K]): this;
+    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void;
+    /**
+     * Pause event delivery. Events emitted while paused are buffered.
+     * Optionally pass a filter to allow specific events through even while paused.
+     */
+    pause(passthrough?: (event: keyof T, args: unknown[]) => boolean): void;
+    private passthroughFn?;
+    /** Resume event delivery and replay buffered events in order. */
+    resume(): void;
+    /** Discard all buffered events without delivering them. */
+    clearBuffer(): void;
+    get isPaused(): boolean;
+    get bufferSize(): number;
+    removeAllListeners(event?: keyof T): void;
+    private deliver;
+}
+
+interface AgentInstanceEvents {
+    agent_event: (event: AgentEvent) => void;
+}
+declare class AgentInstance extends TypedEmitter<AgentInstanceEvents> {
     private connection;
     private child;
     private stderrCapture;
@@ -619,7 +852,6 @@ declare class AgentInstance {
         image?: boolean;
         audio?: boolean;
     };
-    onSessionUpdate: (event: AgentEvent) => void;
     onPermissionRequest: (request: PermissionRequest) => Promise<string>;
     private constructor();
     private static spawnSubprocess;
@@ -686,41 +918,6 @@ declare class AgentManager {
     resume(agentName: string, workingDirectory: string, agentSessionId: string): Promise<AgentInstance>;
 }
 
-/**
- * A minimal, generic typed event emitter.
- *
- * Usage:
- *   interface MyEvents {
- *     data: (payload: string) => void
- *     error: (err: Error) => void
- *   }
- *   const emitter = new TypedEmitter<MyEvents>()
- *   emitter.on('data', (payload) => { ... })
- *   emitter.emit('data', 'hello')
- */
-declare class TypedEmitter<T extends Record<string & keyof T, (...args: any[]) => void>> {
-    private listeners;
-    private paused;
-    private buffer;
-    on<K extends keyof T>(event: K, listener: T[K]): this;
-    off<K extends keyof T>(event: K, listener: T[K]): this;
-    emit<K extends keyof T>(event: K, ...args: Parameters<T[K]>): void;
-    /**
-     * Pause event delivery. Events emitted while paused are buffered.
-     * Optionally pass a filter to allow specific events through even while paused.
-     */
-    pause(passthrough?: (event: keyof T, args: unknown[]) => boolean): void;
-    private passthroughFn?;
-    /** Resume event delivery and replay buffered events in order. */
-    resume(): void;
-    /** Discard all buffered events without delivering them. */
-    clearBuffer(): void;
-    get isPaused(): boolean;
-    get bufferSize(): number;
-    removeAllListeners(event?: keyof T): void;
-    private deliver;
-}
-
 /**
  * Encapsulates pending permission state with a typed Promise API.
  */
@@ -743,6 +940,70 @@ declare class PermissionGate {
     private cleanup;
 }
 
+interface STTOptions {
+    language?: string;
+    model?: string;
+}
+interface STTResult {
+    text: string;
+    language?: string;
+    duration?: number;
+}
+interface TTSOptions {
+    language?: string;
+    voice?: string;
+    model?: string;
+}
+interface TTSResult {
+    audioBuffer: Buffer;
+    mimeType: string;
+}
+interface STTProvider {
+    readonly name: string;
+    transcribe(audioBuffer: Buffer, mimeType: string, options?: STTOptions): Promise<STTResult>;
+}
+interface TTSProvider {
+    readonly name: string;
+    synthesize(text: string, options?: TTSOptions): Promise<TTSResult>;
+}
+interface SpeechProviderConfig {
+    apiKey?: string;
+    model?: string;
+    [key: string]: unknown;
+}
+interface SpeechServiceConfig {
+    stt: {
+        provider: string | null;
+        providers: Record<string, SpeechProviderConfig>;
+    };
+    tts: {
+        provider: string | null;
+        providers: Record<string, SpeechProviderConfig>;
+    };
+}
+
+declare class SpeechService {
+    private config;
+    private sttProviders;
+    private ttsProviders;
+    constructor(config: SpeechServiceConfig);
+    registerSTTProvider(name: string, provider: STTProvider): void;
+    registerTTSProvider(name: string, provider: TTSProvider): void;
+    isSTTAvailable(): boolean;
+    isTTSAvailable(): boolean;
+    transcribe(audioBuffer: Buffer, mimeType: string, options?: STTOptions): Promise<STTResult>;
+    synthesize(text: string, options?: TTSOptions): Promise<TTSResult>;
+    updateConfig(config: SpeechServiceConfig): void;
+}
+
+declare class GroqSTT implements STTProvider {
+    private apiKey;
+    private defaultModel;
+    readonly name = "groq";
+    constructor(apiKey: string, defaultModel?: string);
+    transcribe(audioBuffer: Buffer, mimeType: string, options?: STTOptions): Promise<STTResult>;
+}
+
 interface SessionEvents {
     agent_event: (event: AgentEvent) => void;
     permission_request: (request: PermissionRequest) => void;
@@ -762,16 +1023,20 @@ declare class Session extends TypedEmitter<SessionEvents> {
     private _status;
     name?: string;
     createdAt: Date;
+    voiceMode: "off" | "next" | "on";
     dangerousMode: boolean;
+    archiving: boolean;
     log: Logger;
     readonly permissionGate: PermissionGate;
     private readonly queue;
+    private speechService?;
     constructor(opts: {
         id?: string;
         channelId: string;
         agentName: string;
         workingDirectory: string;
         agentInstance: AgentInstance;
+        speechService?: SpeechService;
     });
     get status(): SessionStatus;
     /** Transition to active — from initializing, error, or cancelled */
@@ -786,8 +1051,11 @@ declare class Session extends TypedEmitter<SessionEvents> {
     /** Number of prompts waiting in queue */
     get queueDepth(): number;
     get promptRunning(): boolean;
+    setVoiceMode(mode: "off" | "next" | "on"): void;
     enqueuePrompt(text: string, attachments?: Attachment[]): Promise<void>;
     private processPrompt;
+    private maybeTranscribeAudio;
+    private processTTSResponse;
     private autoName;
     /** Fire-and-forget warm-up: primes model cache while user types their first message */
     warmup(): Promise<void>;
@@ -908,9 +1176,38 @@ interface SessionStore {
     remove(sessionId: string): Promise<void>;
 }
 
+interface EventBusEvents {
+    "session:created": (data: {
+        sessionId: string;
+        agent: string;
+        status: SessionStatus;
+    }) => void;
+    "session:updated": (data: {
+        sessionId: string;
+        status?: SessionStatus;
+        name?: string;
+        dangerousMode?: boolean;
+    }) => void;
+    "session:deleted": (data: {
+        sessionId: string;
+    }) => void;
+    "agent:event": (data: {
+        sessionId: string;
+        event: AgentEvent;
+    }) => void;
+    "permission:request": (data: {
+        sessionId: string;
+        permission: PermissionRequest;
+    }) => void;
+}
+declare class EventBus extends TypedEmitter<EventBusEvents> {
+}
+
 declare class SessionManager {
     private sessions;
     private store;
+    private eventBus?;
+    setEventBus(eventBus: EventBus): void;
     constructor(store?: SessionStore | null);
     createSession(channelId: string, agentName: string, workingDirectory: string, agentManager: AgentManager): Promise<Session>;
     getSession(sessionId: string): Session | undefined;
@@ -930,10 +1227,23 @@ declare class SessionManager {
     destroyAll(): Promise<void>;
 }
 
+declare class SecurityGuard {
+    private configManager;
+    private sessionManager;
+    constructor(configManager: ConfigManager, sessionManager: SessionManager);
+    checkAccess(message: IncomingMessage): {
+        allowed: true;
+    } | {
+        allowed: false;
+        reason: string;
+    };
+}
+
 interface BridgeDeps {
     messageTransformer: MessageTransformer;
     notificationManager: NotificationManager;
     sessionManager: SessionManager;
+    eventBus?: EventBus;
     fileService?: FileService;
 }
 declare class SessionBridge {
@@ -942,6 +1252,7 @@ declare class SessionBridge {
     private deps;
     private connected;
     private agentEventHandler?;
+    private sessionEventHandler?;
     private statusChangeHandler?;
     private namedHandler?;
     constructor(session: Session, adapter: ChannelAdapter, deps: BridgeDeps);
@@ -953,6 +1264,71 @@ declare class SessionBridge {
     private wireLifecycle;
 }
 
+declare class UsageStore {
+    private filePath;
+    private retentionDays;
+    private records;
+    private debounceTimer;
+    private cleanupInterval;
+    private flushHandler;
+    constructor(filePath: string, retentionDays: number);
+    append(record: UsageRecord): void;
+    query(period: "today" | "week" | "month" | "all"): UsageSummary;
+    getMonthlyTotal(): {
+        totalCost: number;
+        currency: string;
+    };
+    cleanup(): void;
+    flushSync(): void;
+    destroy(): void;
+    private load;
+    private getCutoff;
+    private scheduleDiskWrite;
+}
+
+declare class UsageBudget {
+    private store;
+    private config;
+    private now;
+    private lastNotifiedStatus;
+    private lastNotifiedMonth;
+    constructor(store: UsageStore, config: UsageConfig, now?: () => Date);
+    check(): {
+        status: "ok" | "warning" | "exceeded";
+        message?: string;
+    };
+    getStatus(): {
+        status: "ok" | "warning" | "exceeded";
+        used: number;
+        budget: number;
+        percent: number;
+    };
+}
+
+interface SessionCreateParams {
+    channelId: string;
+    agentName: string;
+    workingDirectory: string;
+    resumeAgentSessionId?: string;
+    existingSessionId?: string;
+    initialName?: string;
+}
+interface SideEffectDeps {
+    usageStore?: UsageStore | null;
+    usageBudget?: UsageBudget | null;
+    notificationManager: NotificationManager;
+    tunnelService?: TunnelService;
+}
+declare class SessionFactory {
+    private agentManager;
+    private sessionManager;
+    private speechService;
+    private eventBus;
+    constructor(agentManager: AgentManager, sessionManager: SessionManager, speechService: SpeechService, eventBus: EventBus);
+    create(params: SessionCreateParams): Promise<Session>;
+    wireSideEffects(session: Session, deps: SideEffectDeps): void;
+}
+
 declare class OpenACPCore {
     configManager: ConfigManager;
     agentCatalog: AgentCatalog;
@@ -961,18 +1337,31 @@ declare class OpenACPCore {
     notificationManager: NotificationManager;
     messageTransformer: MessageTransformer;
     fileService: FileService;
+    readonly speechService: SpeechService;
+    securityGuard: SecurityGuard;
     adapters: Map<string, ChannelAdapter>;
     /** Set by main.ts — triggers graceful shutdown with restart exit code */
     requestRestart: (() => Promise<void>) | null;
     private _tunnelService?;
     private sessionStore;
     private resumeLocks;
+    eventBus: EventBus;
+    sessionFactory: SessionFactory;
+    readonly usageStore: UsageStore | null;
+    readonly usageBudget: UsageBudget | null;
     constructor(configManager: ConfigManager);
     get tunnelService(): TunnelService | undefined;
     set tunnelService(service: TunnelService | undefined);
     registerAdapter(name: string, adapter: ChannelAdapter): void;
     start(): Promise<void>;
     stop(): Promise<void>;
+    archiveSession(sessionId: string): Promise<{
+        ok: true;
+        newThreadId: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
     handleMessage(message: IncomingMessage): Promise<void>;
     createSession(params: {
         channelId: string;
@@ -984,7 +1373,7 @@ declare class OpenACPCore {
         initialName?: string;
     }): Promise<Session>;
     handleNewSession(channelId: string, agentName?: string, workspacePath?: string): Promise<Session>;
-    adoptSession(agentName: string, agentSessionId: string, cwd: string): Promise<{
+    adoptSession(agentName: string, agentSessionId: string, cwd: string, channelId?: string): Promise<{
         ok: true;
         sessionId: string;
         threadId: string;
@@ -995,6 +1384,11 @@ declare class OpenACPCore {
         message: string;
     }>;
     handleNewChat(channelId: string, currentThreadId: string): Promise<Session | null>;
+    /**
+     * Get active session by thread, or attempt lazy resume from store.
+     * Used by adapter command handlers that need a session but don't go through handleMessage().
+     */
+    getOrResumeSession(channelId: string, threadId: string): Promise<Session | null>;
     private lazyResume;
     /** Create a SessionBridge for the given session and adapter */
     createBridge(session: Session, adapter: ChannelAdapter): SessionBridge;
@@ -1002,7 +1396,7 @@ declare class OpenACPCore {
 
 interface AdapterFactory {
     name: string;
-    createAdapter(core: any, config: any): ChannelAdapter;
+    createAdapter(core: OpenACPCore, config: ChannelConfig): ChannelAdapter;
 }
 declare function installPlugin(packageName: string): void;
 declare function uninstallPlugin(packageName: string): void;
@@ -1097,43 +1491,49 @@ declare class ApiServer {
     private startedAt;
     private secret;
     private secretFilePath;
-    constructor(core: OpenACPCore, config: ApiConfig, portFilePath?: string, topicManager?: TopicManager | undefined, secretFilePath?: string);
+    private sseManager;
+    private staticServer;
+    private router;
+    constructor(core: OpenACPCore, config: ApiConfig, portFilePath?: string, topicManager?: TopicManager | undefined, secretFilePath?: string, uiDir?: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     getPort(): number;
+    getSecret(): string;
     private writePortFile;
     private removePortFile;
     private loadOrCreateSecret;
     private authenticate;
     private handleRequest;
-    private handleCreateSession;
-    private handleSendPrompt;
-    private handleGetSession;
-    private handleToggleDangerous;
-    private handleHealth;
-    private handleVersion;
-    private handleGetEditableConfig;
-    private handleGetConfig;
-    private handleUpdateConfig;
-    private handleListAdapters;
-    private handleTunnelStatus;
-    private handleTunnelList;
-    private handleTunnelAdd;
-    private handleTunnelStop;
-    private handleTunnelStopAll;
-    private handleNotify;
-    private handleRestart;
-    private handleCancelSession;
-    private handleListSessions;
-    private handleAdoptSession;
-    private handleListAgents;
     private sendJson;
-    private handleListTopics;
-    private handleDeleteTopic;
-    private handleCleanupTopics;
     private readBody;
 }
 
+interface SessionStats {
+    active: number;
+    total: number;
+}
+declare class SSEManager {
+    private eventBus;
+    private getSessionStats;
+    private startedAt;
+    private sseConnections;
+    private sseCleanupHandlers;
+    private healthInterval?;
+    private boundHandlers;
+    constructor(eventBus: EventBus | undefined, getSessionStats: () => SessionStats, startedAt: number);
+    setup(): void;
+    handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void;
+    broadcast(event: string, data: unknown): void;
+    stop(): void;
+}
+
+declare class StaticServer {
+    private uiDir;
+    constructor(uiDir?: string);
+    isAvailable(): boolean;
+    serve(req: http.IncomingMessage, res: http.ServerResponse): boolean;
+}
+
 interface ConfigFieldDef {
     path: string;
     displayName: string;
@@ -1150,8 +1550,7 @@ declare function isHotReloadable(path: string): boolean;
 declare function resolveOptions(def: ConfigFieldDef, config: Config): string[] | undefined;
 declare function getConfigValue(config: Config, path: string): unknown;
 
-interface TelegramChannelConfig {
-    enabled: boolean;
+interface TelegramChannelConfig extends ChannelConfig {
     botToken: string;
     chatId: number;
     notificationTopicId: number | null;
@@ -1177,6 +1576,7 @@ declare class TelegramAdapter extends ChannelAdapter<OpenACPCore> {
     start(): Promise<void>;
     stop(): Promise<void>;
     private setupRoutes;
+    private messageHandlers;
     sendMessage(sessionId: string, content: OutgoingMessage): Promise<void>;
     sendPermissionRequest(sessionId: string, request: PermissionRequest): Promise<void>;
     sendNotification(notification: NotificationMessage): Promise<void>;
@@ -1188,6 +1588,9 @@ declare class TelegramAdapter extends ChannelAdapter<OpenACPCore> {
     private downloadTelegramFile;
     private handleIncomingMedia;
     cleanupSkillCommands(sessionId: string): Promise<void>;
+    archiveSessionTopic(sessionId: string): Promise<{
+        newThreadId: string;
+    } | null>;
 }
 
-export { type AdapterFactory, AgentCatalog, type AgentCommand, type AgentDefinition, type AgentDistribution, type AgentEvent, AgentInstance, type AgentListItem, AgentManager, AgentStore, type ApiConfig, ApiServer, type Attachment, type AvailabilityResult, type BridgeDeps, CONFIG_REGISTRY, ChannelAdapter, type ChannelConfig, type CleanupResult, type Config, type ConfigFieldDef, ConfigManager, type DeleteTopicResult, type DiscordPlatformData, FileService, type IChannelAdapter, type IncomingMessage, type InstallProgress, type InstallResult, type InstalledAgent, type Logger, type LoggingConfig, MessageTransformer, NotificationManager, type NotificationMessage, OpenACPCore, type OutgoingMessage, PLUGINS_DIR, PermissionGate, type PermissionOption, type PermissionRequest, type PlanEntry, PromptQueue, type RegistryAgent, type RegistryBinaryTarget, type RegistryDistribution, Session, SessionBridge, type SessionEvents, SessionManager, type SessionRecord, type SessionStatus, StderrCapture, TelegramAdapter, type TelegramPlatformData, type TopicInfo, TopicManager, TypedEmitter, cleanupOldSessionLogs, createChildLogger, createSessionLogger, expandHome, getConfigValue, getFieldDef, getPidPath, getSafeFields, getStatus, initLogger, installAutoStart, installPlugin, isAutoStartInstalled, isAutoStartSupported, isHotReloadable, listPlugins, loadAdapterFactory, log, nodeToWebReadable, nodeToWebWritable, resolveOptions, runConfigEditor, setLogLevel, shutdownLogger, startDaemon, stopDaemon, uninstallAutoStart, uninstallPlugin };
+export { type AdapterFactory, AgentCatalog, type AgentCommand, type AgentDefinition, type AgentDistribution, type AgentEvent, AgentInstance, type AgentListItem, AgentManager, AgentStore, type ApiConfig, ApiServer, type Attachment, type AvailabilityResult, type BridgeDeps, CONFIG_REGISTRY, ChannelAdapter, type ChannelConfig, type CleanupResult, type Config, type ConfigFieldDef, ConfigManager, type DeleteTopicResult, type DiscordPlatformData, EventBus, type EventBusEvents, FileService, GroqSTT, type IChannelAdapter, type IncomingMessage, type InstallProgress, type InstallResult, type InstalledAgent, type Logger, type LoggingConfig, MessageTransformer, NotificationManager, type NotificationMessage, OpenACPCore, type OutgoingMessage, PLUGINS_DIR, PermissionGate, type PermissionOption, type PermissionRequest, type PlanEntry, PromptQueue, type RegistryAgent, type RegistryBinaryTarget, type RegistryDistribution, SSEManager, type STTOptions, type STTProvider, type STTResult, SecurityGuard, Session, SessionBridge, type SessionCreateParams, type SessionEvents, SessionFactory, SessionManager, type SessionRecord, type SessionStatus, type SideEffectDeps, type SpeechProviderConfig, SpeechService, type SpeechServiceConfig, StaticServer, StderrCapture, type TTSOptions, type TTSProvider, type TTSResult, TelegramAdapter, type TelegramPlatformData, type TopicInfo, TopicManager, TypedEmitter, UsageBudget, type UsageConfig, type UsageRecord, UsageStore, type UsageSummary, cleanupOldSessionLogs, createChildLogger, createSessionLogger, expandHome, getConfigValue, getFieldDef, getPidPath, getSafeFields, getStatus, initLogger, installAutoStart, installPlugin, isAutoStartInstalled, isAutoStartSupported, isHotReloadable, listPlugins, loadAdapterFactory, log, nodeToWebReadable, nodeToWebWritable, resolveOptions, runConfigEditor, setLogLevel, shutdownLogger, startDaemon, stopDaemon, uninstallAutoStart, uninstallPlugin };