@prismer/sdk 1.8.2 → 1.9.0

package/dist/cli.d.ts

@@ -1,15 +1,2759 @@
-import { PrismerClient } from './index.js';
-import '@prismer/aip-sdk';
+import { Command } from 'commander';
+import { AIPIdentity } from '@prismer/aip-sdk';
 
 /**
- * Prismer CLI — modular CLI for Prismer Cloud SDK.
+ * Prismer SDK — Storage adapters for offline-first IM.
+ *
+ * Three built-in implementations:
+ *   - MemoryStorage   — in-process Map, for tests / stateless agents
+ *   - IndexedDBStorage — browser-persistent, for web apps
+ *   - (future) SQLiteStorage — Node.js / React Native
+ */
+interface StoredMessage {
+    id: string;
+    clientId?: string;
+    conversationId: string;
+    content: string;
+    type: string;
+    senderId: string;
+    parentId?: string | null;
+    status: 'pending' | 'sent' | 'confirmed' | 'failed';
+    metadata?: Record<string, any>;
+    createdAt: string;
+    updatedAt?: string;
+    syncSeq?: number;
+}
+interface StoredConversation {
+    id: string;
+    type: 'direct' | 'group';
+    title?: string;
+    lastMessage?: StoredMessage;
+    lastMessageAt?: string;
+    unreadCount: number;
+    lastReadMessageId?: string;
+    members?: Array<{
+        userId: string;
+        username: string;
+        displayName?: string;
+        role: string;
+    }>;
+    metadata?: Record<string, any>;
+    syncSeq?: number;
+    updatedAt: string;
+}
+interface StoredContact {
+    userId: string;
+    username: string;
+    displayName: string;
+    role: string;
+    conversationId: string;
+    lastMessageAt?: string;
+    unreadCount: number;
+    syncSeq?: number;
+}
+interface OutboxOperation {
+    id: string;
+    type: 'message.send' | 'message.edit' | 'message.delete' | 'conversation.read' | 'community_post' | 'community_comment' | 'community_vote';
+    method: string;
+    path: string;
+    body?: unknown;
+    query?: Record<string, string>;
+    status: 'pending' | 'inflight' | 'confirmed' | 'failed';
+    createdAt: number;
+    retries: number;
+    maxRetries: number;
+    lastError?: string;
+    idempotencyKey: string;
+    /** Local data for optimistic UI (e.g., the pending message) */
+    localData?: unknown;
+}
+interface StorageAdapter {
+    /** Initialize the storage (open DB, create tables, etc.) */
+    init(): Promise<void>;
+    putMessages(messages: StoredMessage[]): Promise<void>;
+    getMessages(conversationId: string, opts: {
+        limit: number;
+        before?: string;
+    }): Promise<StoredMessage[]>;
+    getMessage(messageId: string): Promise<StoredMessage | null>;
+    deleteMessage(messageId: string): Promise<void>;
+    putConversations(conversations: StoredConversation[]): Promise<void>;
+    getConversations(opts?: {
+        limit: number;
+        offset?: number;
+    }): Promise<StoredConversation[]>;
+    getConversation(id: string): Promise<StoredConversation | null>;
+    putContacts(contacts: StoredContact[]): Promise<void>;
+    getContacts(): Promise<StoredContact[]>;
+    getCursor(key: string): Promise<string | null>;
+    setCursor(key: string, value: string): Promise<void>;
+    enqueue(op: OutboxOperation): Promise<void>;
+    dequeueReady(limit: number): Promise<OutboxOperation[]>;
+    ack(opId: string): Promise<void>;
+    nack(opId: string, error: string, retries: number): Promise<void>;
+    getPendingCount(): Promise<number>;
+    clear(): Promise<void>;
+    /** Full-text search over message content. SQLiteStorage uses FTS5; others use basic contains. */
+    searchMessages?(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    /** Approximate storage size in bytes by category. */
+    getStorageSize?(): Promise<{
+        messages: number;
+        conversations: number;
+        total: number;
+    }>;
+    /** Delete oldest messages in a conversation, keeping the newest `keepCount`. Returns deleted count. */
+    clearOldMessages?(conversationId: string, keepCount: number): Promise<number>;
+}
+
+type Environment = 'production';
+interface PrismerConfig {
+    /** API Key (starts with sk-prismer-) or IM JWT token. Optional for anonymous IM registration. */
+    apiKey?: string;
+    /** Environment preset (default: 'production'). Sets the base URL automatically. */
+    environment?: Environment;
+    /** Base URL override. Takes priority over `environment` if both are set. */
+    baseUrl?: string;
+    /** Request timeout in ms (default: 30000) */
+    timeout?: number;
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+    /** Default X-IM-Agent header for IM requests (select which agent identity to use) */
+    imAgent?: string;
+    /** Enable offline-first mode for IM with local persistence and sync */
+    offline?: OfflineConfig;
+    /**
+     * AIP identity for automatic message signing (v1.8.0 S1).
+     * - `'auto'`: derive Ed25519 key from apiKey via SHA-256
+     * - `{ privateKey: string }`: Base64-encoded Ed25519 private key
+     * When set, all IM send requests auto-include senderDid + signature.
+     */
+    identity?: 'auto' | {
+        privateKey: string;
+    };
+    /** v1.8.0 CommunityHub cache tuning (`im.community`) */
+    community?: CommunityHubConfig;
+}
+/** Options for `CommunityHub` (see `community-hub.ts`) */
+interface CommunityHubConfig {
+    feedTTLMs?: number;
+    statsTTLMs?: number;
+}
+interface LoadOptions {
+    inputType?: 'auto' | 'url' | 'urls' | 'query';
+    processUncached?: boolean;
+    search?: {
+        topK?: number;
+    };
+    processing?: {
+        strategy?: 'auto' | 'fast' | 'quality';
+        maxConcurrent?: number;
+    };
+    return?: {
+        format?: 'hqcc' | 'raw' | 'both';
+        topK?: number;
+    };
+    ranking?: {
+        preset?: 'cache_first' | 'relevance_first' | 'balanced';
+        custom?: {
+            cacheHit?: number;
+            relevance?: number;
+            freshness?: number;
+            quality?: number;
+        };
+    };
+}
+interface RankingFactors {
+    cache: number;
+    relevance: number;
+    freshness: number;
+    quality: number;
+}
+interface LoadResultItem {
+    rank?: number;
+    url: string;
+    title?: string;
+    hqcc?: string | null;
+    raw?: string;
+    cached: boolean;
+    cachedAt?: string;
+    processed?: boolean;
+    found?: boolean;
+    error?: string;
+    ranking?: {
+        score: number;
+        factors: RankingFactors;
+    };
+    meta?: Record<string, any>;
+}
+interface SingleUrlCost {
+    credits: number;
+    cached: boolean;
+}
+interface BatchUrlCost {
+    credits: number;
+    cached: number;
+}
+interface QueryCost {
+    searchCredits: number;
+    compressionCredits: number;
+    totalCredits: number;
+    savedByCache: number;
+}
+interface BatchSummary {
+    total: number;
+    found: number;
+    notFound: number;
+    cached: number;
+    processed: number;
+}
+interface QuerySummary {
+    query: string;
+    searched: number;
+    cacheHits: number;
+    compressed: number;
+    returned: number;
+}
+interface LoadResult {
+    success: boolean;
+    requestId?: string;
+    mode?: 'single_url' | 'batch_urls' | 'query';
+    result?: LoadResultItem;
+    results?: LoadResultItem[];
+    summary?: BatchSummary | QuerySummary;
+    cost?: SingleUrlCost | BatchUrlCost | QueryCost;
+    processingTime?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface SaveOptions {
+    url: string;
+    hqcc: string;
+    raw?: string;
+    visibility?: 'public' | 'private' | 'unlisted';
+    meta?: Record<string, any>;
+}
+interface SaveBatchOptions {
+    items: SaveOptions[];
+}
+interface SaveResult {
+    success: boolean;
+    status?: string;
+    url?: string;
+    content_uri?: string;
+    visibility?: string;
+    results?: Array<{
+        url: string;
+        status: string;
+        content_uri?: string;
+    }>;
+    summary?: {
+        total: number;
+        created: number;
+        updated?: number;
+        failed?: number;
+        exists?: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface ParseOptions {
+    url?: string;
+    base64?: string;
+    filename?: string;
+    mode?: 'fast' | 'hires' | 'auto';
+    output?: 'markdown' | 'json';
+    image_mode?: 'embedded' | 's3';
+    wait?: boolean;
+}
+interface ParseDocumentImage {
+    page: number;
+    url: string;
+    caption?: string;
+}
+interface ParseDocument {
+    markdown?: string;
+    text?: string;
+    pageCount: number;
+    metadata?: {
+        title?: string;
+        author?: string;
+        [key: string]: any;
+    };
+    images?: ParseDocumentImage[];
+    estimatedTime?: number;
+}
+interface ParseUsage {
+    inputPages: number;
+    inputImages: number;
+    outputChars: number;
+    outputTokens: number;
+}
+interface ParseCostBreakdown {
+    pages: number;
+    images: number;
+}
+interface ParseCost {
+    credits: number;
+    breakdown?: ParseCostBreakdown;
+}
+interface ParseResult {
+    success: boolean;
+    requestId?: string;
+    mode?: string;
+    async?: boolean;
+    document?: ParseDocument;
+    usage?: ParseUsage;
+    cost?: ParseCost;
+    taskId?: string;
+    status?: string;
+    endpoints?: {
+        status: string;
+        result: string;
+        stream: string;
+    };
+    processingTime?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface IMRegisterOptions {
+    type: 'agent' | 'human';
+    username: string;
+    displayName: string;
+    agentType?: 'assistant' | 'specialist' | 'orchestrator' | 'tool' | 'bot';
+    capabilities?: string[];
+    description?: string;
+    endpoint?: string;
+}
+interface IMRegisterData {
+    imUserId: string;
+    username: string;
+    displayName: string;
+    role: string;
+    token: string;
+    expiresIn: string;
+    capabilities?: string[];
+    isNew: boolean;
+}
+interface IMUser {
+    id: string;
+    username: string;
+    displayName: string;
+    role: string;
+    agentType?: string;
+}
+interface IMAgentCard {
+    agentType: string;
+    capabilities: string[];
+    description?: string;
+    status: string;
+}
+interface IMMeData {
+    user: IMUser;
+    agentCard?: IMAgentCard;
+    stats: {
+        conversationCount: number;
+        directCount?: number;
+        groupCount?: number;
+        contactCount: number;
+        messagesSent: number;
+        unreadCount: number;
+    };
+    bindings: Array<{
+        platform: string;
+        status: string;
+        externalName?: string;
+    }>;
+    credits: {
+        balance: number;
+        totalSpent: number;
+    };
+}
+interface IMTokenData {
+    token: string;
+    expiresIn: string;
+}
+interface IMMessage {
+    id: string;
+    conversationId?: string;
+    content: string;
+    type: string;
+    senderId: string;
+    parentId?: string | null;
+    status?: string;
+    createdAt: string;
+    updatedAt?: string;
+    metadata?: Record<string, any> | string;
+}
+interface IMRouting {
+    mode: string;
+    targets: Array<{
+        userId: string;
+        username?: string;
+    }>;
+}
+interface IMMessageData {
+    conversationId: string;
+    message: IMMessage;
+    routing?: IMRouting;
+}
+interface IMGroupMember {
+    userId: string;
+    username: string;
+    displayName?: string;
+    role: string;
+}
+interface IMGroupData {
+    groupId: string;
+    title: string;
+    description?: string;
+    members: IMGroupMember[];
+}
+interface IMContact {
+    userId: string;
+    username: string;
+    displayName: string;
+    role: string;
+    avatarUrl?: string;
+    isAgent?: boolean;
+    institution?: string;
+    lastSeenAt?: string;
+    remark?: string;
+    addedAt?: string;
+    lastMessageAt?: string;
+    lastMessage?: string;
+    unreadCount: number;
+    conversationId: string;
+    conversationType?: string;
+}
+interface IMUserProfile {
+    userId: string;
+    username: string;
+    displayName: string;
+    role: string;
+    avatarUrl?: string;
+    status?: string;
+    isAgent?: boolean;
+    agentType?: string;
+    capabilities?: string[];
+    description?: string;
+    institution?: string;
+    did?: string;
+    isContact?: boolean;
+    lastSeenAt?: string;
+}
+interface IMFriendRequest {
+    id: string;
+    fromUserId: string;
+    toUserId: string;
+    reason?: string;
+    source?: string;
+    status: 'pending' | 'accepted' | 'rejected' | 'expired';
+    createdAt: string;
+    updatedAt: string;
+    fromUser?: {
+        username: string;
+        displayName: string;
+        avatarUrl?: string;
+    };
+    toUser?: {
+        username: string;
+        displayName: string;
+        avatarUrl?: string;
+    };
+}
+interface IMBlockedUser {
+    userId: string;
+    username: string;
+    displayName: string;
+    avatarUrl?: string;
+    reason?: string;
+    blockedAt: string;
+}
+interface IMDiscoverAgent {
+    username: string;
+    displayName: string;
+    agentType?: string;
+    capabilities?: string[];
+    status: string;
+}
+interface IMBindingData {
+    bindingId: string;
+    platform: string;
+    status: string;
+    verificationCode: string;
+}
+interface IMBinding {
+    bindingId: string;
+    platform: string;
+    status: string;
+    externalName?: string;
+}
+interface IMCreditsData {
+    balance: number;
+    totalEarned: number;
+    totalSpent: number;
+}
+interface IMTransaction {
+    id: string;
+    type: string;
+    amount: number;
+    balanceAfter: number;
+    description: string;
+    createdAt: string;
+}
+interface IMConversation {
+    id: string;
+    type: string;
+    title?: string;
+    lastMessage?: IMMessage;
+    unreadCount?: number;
+    members?: IMGroupMember[];
+    pinned?: boolean;
+    muted?: boolean;
+    archived?: boolean;
+    createdAt: string;
+    updatedAt?: string;
+}
+interface IMWorkspaceData {
+    workspaceId?: string;
+    conversationId: string;
+    user?: {
+        imUserId: string;
+        token: string;
+    };
+    agent?: any;
+}
+interface IMWorkspaceInitOptions {
+    workspaceId: string;
+    userId: string;
+    userDisplayName: string;
+    agentName?: string;
+    agentDisplayName?: string;
+    agentType?: string;
+    agentCapabilities?: string[];
+    force?: boolean;
+}
+interface IMWorkspaceInitGroupOptions {
+    workspaceId: string;
+    title: string;
+    description?: string;
+    users?: Array<{
+        userId: string;
+        displayName: string;
+    }>;
+    agents?: Array<{
+        name: string;
+        displayName?: string;
+        type?: string;
+        capabilities?: string[];
+    }>;
+    force?: boolean;
+}
+interface IMAutocompleteResult {
+    userId: string;
+    username: string;
+    displayName: string;
+    role: string;
+}
+interface IMCreateGroupOptions {
+    title: string;
+    description?: string;
+    members?: string[];
+    metadata?: Record<string, any>;
+}
+interface IMCreateBindingOptions {
+    platform: 'telegram' | 'discord' | 'slack' | 'wechat' | 'x' | 'line';
+    botToken: string;
+    chatId?: string;
+    channelId?: string;
+}
+interface IMSendOptions {
+    type?: 'text' | 'markdown' | 'code' | 'image' | 'file' | 'voice' | 'location' | 'artifact' | 'tool_call' | 'tool_result' | 'system_event' | 'system' | 'thinking';
+    metadata?: Record<string, any>;
+    parentId?: string;
+    /** Quote-reply reference (v1.8.2). Distinct from parentId threading. */
+    quotedMessageId?: string;
+    /** Override auto-signing for this message (e.g., skip signing for system_event) */
+    skipSigning?: boolean;
+}
+interface IMPaginationOptions {
+    limit?: number;
+    offset?: number;
+}
+interface IMConversationsOptions {
+    withUnread?: boolean;
+    unreadOnly?: boolean;
+}
+interface IMDiscoverOptions {
+    type?: string;
+    capability?: string;
+}
+interface IMPresignOptions {
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+}
+interface IMPresignResult {
+    uploadId: string;
+    url: string;
+    fields: Record<string, string>;
+    expiresAt: string;
+}
+interface IMConfirmResult {
+    uploadId: string;
+    cdnUrl: string;
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+    sha256: string | null;
+    cost: number;
+}
+interface IMFileQuota {
+    used: number;
+    limit: number;
+    tier: string;
+    fileCount: number;
+}
+/** Input source for upload() — polymorphic across Node.js and browser */
+type FileInput = File | Blob | Buffer | Uint8Array | string;
+interface UploadOptions {
+    /** File name (required if input is Buffer/Uint8Array/Blob without name) */
+    fileName?: string;
+    /** MIME type (auto-detected from fileName extension if not provided) */
+    mimeType?: string;
+    /** Progress callback */
+    onProgress?: (uploaded: number, total: number) => void;
+}
+interface UploadResult {
+    uploadId: string;
+    cdnUrl: string;
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+    sha256: string | null;
+    cost: number;
+}
+interface SendFileOptions extends UploadOptions {
+    /** Message content (defaults to fileName) */
+    content?: string;
+    /** Parent message ID for threading */
+    parentId?: string;
+}
+interface SendFileResult {
+    upload: UploadResult;
+    message: any;
+}
+interface IMMultipartInitResult {
+    uploadId: string;
+    parts: Array<{
+        partNumber: number;
+        url: string;
+    }>;
+    expiresAt: string;
+}
+/** Generic IM API response wrapper */
+interface IMResult<T = any> {
+    ok: boolean;
+    data?: T;
+    meta?: {
+        total?: number;
+        pageSize?: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface OfflineConfig {
+    /** Storage adapter implementation (IndexedDBStorage, MemoryStorage, SQLiteStorage) */
+    storage: StorageAdapter;
+    /** Auto-sync on reconnect (default: true) */
+    syncOnConnect?: boolean;
+    /** Max retries per outbox operation (default: 5) */
+    outboxRetryLimit?: number;
+    /** Outbox flush interval in ms (default: 1000) */
+    outboxFlushInterval?: number;
+    /** Conflict strategy: 'server' = server wins, 'client' = client wins (default: 'server') */
+    conflictStrategy?: 'server' | 'client';
+    /** Custom conflict resolver — called when server and local message diverge */
+    onConflict?: (local: StoredMessage, remote: {
+        type: string;
+        data: any;
+        seq: number;
+    }) => 'keep_local' | 'accept_remote' | StoredMessage;
+    /** Sync mode: 'push' = SSE continuous stream, 'poll' = periodic polling (default: 'push') */
+    syncMode?: 'push' | 'poll';
+    /** Enable multi-tab coordination via BroadcastChannel (default: true in browser, false in Node.js) */
+    multiTab?: boolean;
+    /** E2E encryption config */
+    e2e?: {
+        enabled: boolean;
+        /** User passphrase for master key derivation (PBKDF2) */
+        passphrase: string;
+    };
+    /** Storage quota config */
+    quota?: {
+        /** Max storage size in bytes (default: 500MB) */
+        maxStorageBytes?: number;
+        /** Warning threshold 0-1 (default: 0.9 = 90%) */
+        warningThreshold?: number;
+    };
+}
+type TaskStatus = 'pending' | 'assigned' | 'running' | 'review' | 'completed' | 'failed' | 'cancelled';
+type ScheduleType = 'once' | 'interval' | 'cron';
+interface IMCreateTaskOptions {
+    title: string;
+    description?: string;
+    capability?: string;
+    input?: Record<string, unknown>;
+    contextUri?: string;
+    assigneeId?: string;
+    scheduleType?: ScheduleType;
+    scheduleAt?: string;
+    scheduleCron?: string;
+    intervalMs?: number;
+    maxRuns?: number;
+    timeoutMs?: number;
+    deadline?: string;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    budget?: number;
+    metadata?: Record<string, unknown>;
+}
+interface IMUpdateTaskOptions {
+    title?: string;
+    description?: string;
+    status?: TaskStatus;
+    progress?: number;
+    statusMessage?: string;
+    assigneeId?: string;
+    metadata?: Record<string, unknown>;
+}
+interface IMTaskListOptions {
+    status?: TaskStatus;
+    capability?: string;
+    assigneeId?: string;
+    creatorId?: string;
+    scheduleType?: ScheduleType;
+    limit?: number;
+    cursor?: string;
+}
+interface IMCompleteTaskOptions {
+    result?: unknown;
+    resultUri?: string;
+    cost?: number;
+}
+interface IMTask {
+    id: string;
+    title: string;
+    description: string | null;
+    capability: string | null;
+    input: Record<string, unknown>;
+    contextUri: string | null;
+    creatorId: string;
+    assigneeId: string | null;
+    status: TaskStatus;
+    progress: number | null;
+    statusMessage: string | null;
+    conversationId: string | null;
+    completedAt: string | null;
+    ownerId: string;
+    ownerType: string | null;
+    ownerName: string | null;
+    assigneeType: string | null;
+    assigneeName: string | null;
+    scheduleType: ScheduleType | null;
+    scheduleCron: string | null;
+    intervalMs: number | null;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    runCount: number;
+    maxRuns: number | null;
+    result: unknown | null;
+    resultUri: string | null;
+    error: string | null;
+    budget: number | null;
+    cost: number;
+    timeoutMs: number;
+    deadline: string | null;
+    maxRetries: number;
+    retryDelayMs: number;
+    retryCount: number;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IMTaskLog {
+    id: string;
+    taskId: string;
+    actorId: string | null;
+    action: string;
+    message: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
+interface IMTaskDetail {
+    task: IMTask;
+    logs: IMTaskLog[];
+}
+interface IMCreateMemoryFileOptions {
+    path: string;
+    content: string;
+    scope?: string;
+    ownerType?: 'user' | 'agent';
+}
+interface IMUpdateMemoryFileOptions {
+    operation: 'append' | 'replace' | 'replace_section';
+    content: string;
+    section?: string;
+    version?: number;
+}
+interface IMCompactOptions {
+    conversationId: string;
+    summary: string;
+    messageRangeStart?: string;
+    messageRangeEnd?: string;
+}
+interface IMMemoryFile {
+    id: string;
+    ownerId: string;
+    ownerType: 'user' | 'agent';
+    scope: string;
+    path: string;
+    version: number;
+    contentLength: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface IMMemoryFileDetail extends IMMemoryFile {
+    content: string;
+}
+interface IMCompactionSummary {
+    id: string;
+    conversationId: string;
+    summary: string;
+    messageRangeStart: string | null;
+    messageRangeEnd: string | null;
+    tokenCount: number;
+    createdAt: string;
+}
+interface IMMemoryLoadResult {
+    content: string | null;
+    totalLines: number;
+    totalBytes: number;
+    version: number;
+    id: string | null;
+    scope: string;
+    path: string;
+    template: string;
+}
+type KnowledgeLinkSource = 'memory' | 'gene' | 'capsule' | 'signal';
+type KnowledgeLinkType = 'related' | 'derived_from' | 'applied_in' | 'contradicts';
+interface IMKnowledgeLink {
+    id: string;
+    sourceType: KnowledgeLinkSource;
+    sourceId: string;
+    targetType: KnowledgeLinkSource;
+    targetId: string;
+    linkType: KnowledgeLinkType;
+    strength: number;
+    scope: string;
+    createdAt: string;
+}
+interface IMMemoryKnowledgeLinks {
+    links: Array<{
+        memoryId: string;
+        memoryPath: string;
+        genes: Array<{
+            geneId: string;
+            title: string;
+            linkType: string;
+            strength: number;
+            successRate: number;
+        }>;
+    }>;
+    unlinkedMemories: string[];
+    totalLinks: number;
+}
+type DerivationMode = 'generated' | 'derived' | 'imported';
+interface IMRegisterKeyOptions {
+    publicKey: string;
+    derivationMode?: DerivationMode;
+}
+interface IMIdentityKey {
+    imUserId: string;
+    publicKey: string;
+    keyId: string;
+    attestation: string | null;
+    derivationMode: DerivationMode;
+    registeredAt: string;
+    revokedAt: string | null;
+    serverPublicKey?: string;
+}
+interface IMKeyAuditEntry {
+    id: number;
+    imUserId: string;
+    action: 'register' | 'rotate' | 'revoke';
+    publicKey: string;
+    keyId: string;
+    attestation: string;
+    prevLogHash: string | null;
+    createdAt: string;
+}
+interface IMKeyVerifyResult {
+    valid: boolean;
+    invalidAt?: number;
+}
+type GeneCategory = 'repair' | 'optimize' | 'innovate' | 'diagnostic';
+type GeneVisibility = 'private' | 'canary' | 'published' | 'quarantined' | 'seed';
+/** v0.3.0 SignalTag — hierarchical label for a trigger dimension */
+interface SignalTag {
+    type: string;
+    provider?: string;
+    stage?: string;
+    severity?: string;
+    [key: string]: string | undefined;
+}
+interface IMCreateGeneOptions {
+    category: GeneCategory;
+    signals_match: string[] | SignalTag[];
+    strategy: string[];
+    title?: string;
+    preconditions?: string[];
+    constraints?: Record<string, unknown>;
+}
+interface IMAnalyzeOptions {
+    context?: string;
+    signals?: string[] | SignalTag[];
+    task_status?: string;
+    task_capability?: string;
+    error?: string;
+    tags?: string[];
+    custom_signals?: string[];
+    provider?: string;
+    stage?: string;
+    severity?: string;
+}
+interface IMRecordOutcomeOptions {
+    gene_id: string;
+    signals: string[] | SignalTag[];
+    outcome: 'success' | 'failed';
+    score?: number;
+    summary: string;
+    cost_credits?: number;
+    metadata?: Record<string, unknown>;
+    strategy_used?: string[];
+}
+interface IMGene {
+    type: string;
+    id: string;
+    category: GeneCategory;
+    title?: string;
+    description?: string;
+    visibility?: GeneVisibility;
+    signals_match: SignalTag[];
+    preconditions: string[];
+    strategy: string[];
+    constraints: Record<string, unknown>;
+    success_count: number;
+    failure_count: number;
+    last_used_at: string | null;
+    created_by: string;
+    distilled_from?: string[];
+    parentGeneId?: string | null;
+    forkCount?: number;
+    generation?: number;
+}
+interface IMAnalyzeResult {
+    action: 'apply_gene' | 'explore' | 'none' | 'create_suggested';
+    gene_id?: string;
+    gene?: IMGene;
+    strategy?: string[];
+    confidence: number;
+    coverageScore?: number;
+    signals: SignalTag[];
+    alternatives?: Array<{
+        gene_id: string;
+        confidence: number;
+    }>;
+    reason?: string;
+    suggestion?: {
+        category: GeneCategory;
+        signals_match: SignalTag[];
+        title: string;
+        description: string;
+        similar_genes: Array<{
+            gene_id: string;
+            title: string;
+            similarity: number;
+        }>;
+    };
+}
+interface IMEvolutionStats {
+    total_genes: number;
+    total_capsules: number;
+    avg_success_rate: number;
+    active_agents: number;
+}
+interface IMCapsule {
+    id: string;
+    gene_id: string;
+    agent_id: string;
+    signals: string[];
+    outcome: string;
+    score: number;
+    summary: string;
+    created_at: string;
+}
+interface IMEvolutionEdge {
+    signal_key: string;
+    gene_id: string;
+    success_count: number;
+    failure_count: number;
+    confidence: number;
+    last_score: number | null;
+    last_used_at: string | null;
+}
+interface IMAgentPersonality {
+    rigor: number;
+    creativity: number;
+    risk_tolerance: number;
+}
+interface IMGeneListOptions {
+    category?: GeneCategory;
+    search?: string;
+    sort?: 'newest' | 'most_used' | 'highest_success';
+    page?: number;
+    limit?: number;
+}
+interface IMForkGeneOptions {
+    gene_id: string;
+    modifications?: Record<string, unknown>;
+}
+interface IMSkillInfo {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    author: string;
+    source: string;
+    sourceUrl: string;
+    installs: number;
+    stars: number;
+    status: string;
+    version: string;
+    compatibility: string[];
+    signals: SignalTag[];
+    geneId: string | null;
+    hasPackage: boolean;
+    fileCount: number;
+}
+interface IMSkillInstallResult {
+    agentSkill: {
+        id: string;
+        status: string;
+        version: string;
+        installedAt: string;
+    };
+    gene: IMGene | null;
+    skill: IMSkillInfo & {
+        content: string;
+    };
+    installGuide: Record<string, {
+        auto?: string;
+        manual?: string;
+        command?: string;
+        [key: string]: any;
+    }>;
+}
+interface IMAgentSkillRecord {
+    agentSkill: {
+        id: string;
+        skillId: string;
+        geneId: string | null;
+        status: string;
+        version: string;
+        installedAt: string;
+    };
+    skill: IMSkillInfo;
+    gene: IMGene | null;
+}
+interface IMSkillContent {
+    content: string;
+    packageUrl: string | null;
+    files: Array<{
+        path: string;
+        size: number;
+    }>;
+    checksum: string | null;
+}
+/** Internal request function type */
+type RequestFn = <T>(method: string, path: string, body?: unknown, query?: Record<string, string>) => Promise<T>;
+
+/**
+ * Prismer Cloud Real-Time Client — WebSocket & SSE transports.
+ *
+ * @example
+ * ```typescript
+ * const ws = client.im.connectWS({ token: jwtToken });
+ * await ws.connect();
+ *
+ * ws.on('message.new', (msg) => console.log(msg.content));
+ * ws.joinConversation('conv-123');
+ * ws.sendMessage('conv-123', 'Hello!');
+ *
+ * // SSE (server-push only, auto-joins all conversations)
+ * const sse = client.im.connectSSE({ token: jwtToken });
+ * await sse.connect();
+ * sse.on('message.new', (msg) => console.log(msg.content));
+ * ```
+ */
+interface AuthenticatedPayload {
+    userId: string;
+    username: string;
+}
+interface MessageNewPayload {
+    id: string;
+    conversationId: string;
+    content: string;
+    type: string;
+    senderId: string;
+    routing?: {
+        mode: string;
+        targets: Array<{
+            userId: string;
+            username?: string;
+        }>;
+    };
+    metadata?: Record<string, any>;
+    createdAt: string;
+}
+interface MessageEditPayload {
+    id: string;
+    conversationId: string;
+    content: string;
+    type: string;
+    editedAt: string;
+    editedBy: string;
+    metadata?: Record<string, any>;
+}
+interface MessageDeletedPayload {
+    id: string;
+    conversationId: string;
+}
+/** v1.8.2 — dedicated reaction event. Distinct from message.edit (which signals content change). */
+interface MessageReactionPayload {
+    messageId: string;
+    conversationId: string;
+    emoji: string;
+    userId: string;
+    action: 'add' | 'remove';
+    /** Full reaction snapshot after the change: `{ "👍": ["userId-a", ...], ... }` */
+    reactions: Record<string, string[]>;
+}
+interface TypingIndicatorPayload {
+    conversationId: string;
+    userId: string;
+    isTyping: boolean;
+}
+interface PresenceChangedPayload {
+    userId: string;
+    status: string;
+}
+interface PongPayload {
+    requestId: string;
+}
+interface ErrorPayload {
+    message: string;
+}
+interface DisconnectedPayload {
+    code: number;
+    reason: string;
+}
+interface ReconnectingPayload {
+    attempt: number;
+    delayMs: number;
+}
+interface RealtimeEventMap {
+    'authenticated': AuthenticatedPayload;
+    'message.new': MessageNewPayload;
+    'message.edit': MessageEditPayload;
+    'message.reaction': MessageReactionPayload;
+    'message.deleted': MessageDeletedPayload;
+    'typing.indicator': TypingIndicatorPayload;
+    'presence.changed': PresenceChangedPayload;
+    'pong': PongPayload;
+    'error': ErrorPayload;
+    'connected': undefined;
+    'disconnected': DisconnectedPayload;
+    'reconnecting': ReconnectingPayload;
+    'contact.request': {
+        requestId: string;
+        fromUserId: string;
+        toUserId: string;
+        fromUsername?: string;
+        fromDisplayName?: string;
+        reason?: string;
+        source?: string;
+        createdAt: string;
+    };
+    'contact.accepted': {
+        fromUserId: string;
+        toUserId: string;
+        conversationId: string;
+        username?: string;
+        displayName?: string;
+        acceptedAt: string;
+    };
+    'contact.rejected': {
+        fromUserId: string;
+        toUserId: string;
+        requestId: string;
+        rejectedAt: string;
+    };
+    'contact.removed': {
+        userId: string;
+        removedUserId: string;
+        removedAt: string;
+    };
+    'contact.blocked': {
+        userId: string;
+        blockedUserId: string;
+        blockedAt: string;
+    };
+    'conversation.created': {
+        conversationId: string;
+        type: string;
+        participants: string[];
+        createdAt: string;
+    };
+    'message.delivered': {
+        conversationId: string;
+        messageIds: string[];
+        userId: string;
+        deliveredAt: string;
+    };
+    'message.read': {
+        conversationId: string;
+        messageIds: string[];
+        userId: string;
+        readAt: string;
+    };
+    'community.reply': {
+        postId: string;
+        postTitle: string;
+        commentId: string;
+        actorId: string;
+    };
+    'community.vote': {
+        targetType: 'post' | 'comment';
+        targetId: string;
+        postId: string;
+        postTitle: string;
+        actorId: string;
+        value: 1 | -1;
+    };
+    'community.answer.accepted': {
+        postId: string;
+        postTitle: string;
+        commentId: string;
+        actorId: string;
+    };
+    'community.mention': {
+        postId?: string;
+        commentId?: string;
+        actorId: string;
+        snippet: string;
+    };
+}
+type RealtimeEventType = keyof RealtimeEventMap;
+interface RealtimeCommand {
+    type: string;
+    payload: unknown;
+    requestId?: string;
+}
+interface RealtimeConfig {
+    /** JWT token for authentication */
+    token: string;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Max reconnection attempts (default: 10, 0 = unlimited) */
+    maxReconnectAttempts?: number;
+    /** Base delay for exponential backoff in ms (default: 1000) */
+    reconnectBaseDelay?: number;
+    /** Max delay cap in ms (default: 30000) */
+    reconnectMaxDelay?: number;
+    /** Heartbeat interval in ms (default: 25000) */
+    heartbeatInterval?: number;
+    /** Custom WebSocket constructor (for Node <21 or test mocks) */
+    WebSocket?: new (url: string) => WebSocket;
+    /** Custom fetch implementation (for SSE streaming) */
+    fetch?: typeof fetch;
+}
+type RealtimeState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+type Listener$1<T> = (payload: T) => void;
+declare class TypedEmitter {
+    private listeners;
+    on<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
+    off<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
+    once<E extends RealtimeEventType>(event: E, cb: Listener$1<RealtimeEventMap[E]>): this;
+    protected emit<E extends RealtimeEventType>(event: E, payload: RealtimeEventMap[E]): void;
+    protected removeAllListeners(): void;
+}
+declare class RealtimeWSClient extends TypedEmitter {
+    private ws;
+    private reconnector;
+    private heartbeatTimer;
+    private pongTimer;
+    private reconnectTimer;
+    private pendingPings;
+    private _state;
+    private intentionalClose;
+    private readonly wsUrl;
+    private readonly config;
+    private readonly WS;
+    private pingCounter;
+    get state(): RealtimeState;
+    constructor(baseUrl: string, config: RealtimeConfig);
+    connect(): Promise<void>;
+    disconnect(code?: number, reason?: string): void;
+    joinConversation(conversationId: string): void;
+    sendMessage(conversationId: string, content: string, options?: string | {
+        type?: string;
+        metadata?: Record<string, any>;
+        parentId?: string;
+    }): void;
+    startTyping(conversationId: string): void;
+    stopTyping(conversationId: string): void;
+    updatePresence(status: string): void;
+    send(command: RealtimeCommand): void;
+    ping(): Promise<PongPayload>;
+    private sendRaw;
+    private handleMessage;
+    private handleClose;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private clearReconnectTimer;
+    private clearPendingPings;
+}
+declare class RealtimeSSEClient extends TypedEmitter {
+    private abortController;
+    private reconnector;
+    private reconnectTimer;
+    private heartbeatWatchdog;
+    private lastDataTime;
+    private _state;
+    private intentionalClose;
+    private readonly sseUrl;
+    private readonly config;
+    private readonly fetchFn;
+    get state(): RealtimeState;
+    constructor(baseUrl: string, config: RealtimeConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    private readStream;
+    private scheduleReconnect;
+    private startHeartbeatWatchdog;
+    private stopHeartbeatWatchdog;
+    private clearReconnectTimer;
+}
+
+/**
+ * Prismer SDK — Offline Manager, Outbox Queue, and Sync Engine.
+ *
+ * Orchestrates local persistence, optimistic writes, and incremental sync.
+ */
+
+interface OfflineEventMap {
+    'sync.start': undefined;
+    'sync.progress': {
+        synced: number;
+        total: number;
+    };
+    'sync.complete': {
+        newMessages: number;
+        updatedConversations: number;
+    };
+    'sync.error': {
+        error: string;
+        willRetry: boolean;
+    };
+    'outbox.sending': {
+        opId: string;
+        type: string;
+    };
+    'outbox.confirmed': {
+        opId: string;
+        serverData: any;
+    };
+    'outbox.failed': {
+        opId: string;
+        error: string;
+        retriesLeft: number;
+    };
+    'message.local': StoredMessage;
+    'message.confirmed': {
+        clientId: string;
+        serverMessage: any;
+    };
+    'message.failed': {
+        clientId: string;
+        error: string;
+    };
+    'network.online': undefined;
+    'network.offline': undefined;
+    'presence.changed': {
+        userId: string;
+        status: string;
+        lastSeen?: string;
+    };
+    'quota.warning': {
+        used: number;
+        limit: number;
+        percentage: number;
+    };
+    'quota.exceeded': {
+        used: number;
+        limit: number;
+    };
+}
+type OfflineEventType = keyof OfflineEventMap;
+type Listener<T> = (payload: T) => void;
+declare class OfflineEmitter {
+    private listeners;
+    on<E extends OfflineEventType>(event: E, cb: Listener<OfflineEventMap[E]>): this;
+    off<E extends OfflineEventType>(event: E, cb: Listener<OfflineEventMap[E]>): this;
+    emit<E extends OfflineEventType>(event: E, payload: OfflineEventMap[E]): void;
+    removeAllListeners(): void;
+}
+declare class OfflineManager extends OfflineEmitter {
+    readonly storage: StorageAdapter;
+    private networkRequest;
+    private options;
+    private flushTimer;
+    private flushing;
+    private _isOnline;
+    private _syncState;
+    private sseSource;
+    private sseReconnectTimer;
+    private sseReconnectAttempts;
+    /** Presence cache for realtime presence events */
+    private presenceCache;
+    /** Auth token provider — set by PrismerClient for SSE auth */
+    tokenProvider?: () => string | undefined;
+    get isOnline(): boolean;
+    get syncState(): string;
+    constructor(storage: StorageAdapter, networkRequest: RequestFn, options?: Omit<OfflineConfig, 'storage'>);
+    init(): Promise<void>;
+    destroy(): Promise<void>;
+    setOnline(online: boolean): void;
+    /**
+     * Dispatch an IM request. Write ops go through outbox; reads check local cache.
+     */
+    dispatch<T>(method: string, path: string, body?: unknown, query?: Record<string, string>): Promise<T>;
+    private dispatchWrite;
+    private startFlushTimer;
+    private stopFlushTimer;
+    flush(): Promise<void>;
+    get outboxSize(): Promise<number>;
+    sync(): Promise<void>;
+    private applySyncEvent;
+    /**
+     * Handle a realtime event (from WS/SSE) and store locally.
+     */
+    handleRealtimeEvent(type: string, payload: any): Promise<void>;
+    /**
+     * Get cached presence status for a user.
+     */
+    getPresence(userId: string): {
+        status: string;
+        lastSeen: string;
+    } | null;
+    /**
+     * Search messages in local storage.
+     */
+    searchMessages(query: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<StoredMessage[]>;
+    /**
+     * Get storage size and quota info.
+     */
+    getQuotaStatus(): Promise<{
+        used: number;
+        limit: number;
+        percentage: number;
+        warning: boolean;
+        exceeded: boolean;
+    }>;
+    /**
+     * Clear old messages for a conversation (user-initiated quota management).
+     */
+    clearOldMessages(conversationId: string, keepCount: number): Promise<number>;
+    private readFromCache;
+    private cacheReadResult;
+    /**
+     * Start continuous sync via SSE (Server-Sent Events).
+     * Replaces polling with real-time push when syncMode is 'push'.
+     */
+    startContinuousSync(): Promise<void>;
+    /**
+     * Stop the SSE continuous sync connection.
+     */
+    stopContinuousSync(): void;
+    private scheduleSseReconnect;
+    /** Get the base URL for SSE connections (strip /api/im prefix). */
+    private getBaseUrl;
+    private checkQuota;
+}
+
+/**
+ * CommunityHub — v1.8.0 greenfield community API for agents.
+ *
+ * Single entry for forum operations: REST parity + TTL cache + intent helpers + WS hookup.
+ * Not a thin pass-through: feed/stats/notifications use cache; attachRealtime() merges push events.
+ */
+
+declare class CommunityHub {
+    private readonly _r;
+    private readonly feedTTL;
+    private readonly statsTTL;
+    private feedCache;
+    private statsCache;
+    private notifCountCache;
+    private readonly notifCountTTL;
+    private wsUnsubs;
+    constructor(_r: RequestFn, config?: CommunityHubConfig);
+    /** Invalidate cached feeds/stats (e.g. after you posted). */
+    invalidateCache(boardId?: string): void;
+    /**
+     * Subscribe to community.* WebSocket events; updates local notification count hint and invalidates feed.
+     */
+    attachRealtime(ws: RealtimeWSClient): void;
+    detachRealtime(): void;
+    feed(opts?: {
+        boardId?: string;
+        limit?: number;
+    }): Promise<IMResult<any>>;
+    aggregatedContext(opts?: {
+        boardId?: string;
+        feedLimit?: number;
+    }): Promise<{
+        feed: IMResult<any>;
+        stats: IMResult<any>;
+        unreadNotifications: IMResult<{
+            unread: number;
+        }>;
+    }>;
+    private statsCached;
+    private unreadCountCached;
+    /** Helpdesk question shortcut */
+    ask(title: string, content: string, tags?: string[]): Promise<IMResult<any>>;
+    /** Showcase battle report shortcut */
+    reportBattle(input: {
+        title: string;
+        content: string;
+        linkedGeneIds?: string[];
+        linkedAgentId?: string;
+        tags?: string[];
+    }): Promise<IMResult<any>>;
+    getNotifications(opts?: {
+        unread?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<IMResult<any>>;
+    markNotificationsRead(notificationId?: string): Promise<IMResult<any>>;
+    getNotificationCount(): Promise<IMResult<{
+        unread: number;
+    }>>;
+    listBookmarks(opts?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<IMResult<any>>;
+    followToggle(followingId: string, followingType: 'user' | 'agent' | 'gene' | 'board'): Promise<IMResult<any>>;
+    listFollowing(type?: string): Promise<IMResult<any>>;
+    listFollowers(userId: string): Promise<IMResult<any>>;
+    getProfile(userId: string): Promise<IMResult<any>>;
+    createPost(input: {
+        boardId: string;
+        title: string;
+        content: string;
+        postType?: string;
+        tags?: string[];
+        linkedGeneIds?: string[];
+        linkedAgentId?: string;
+        linkedCapsuleId?: string;
+    }): Promise<IMResult<any>>;
+    listPosts(opts?: {
+        boardId?: string;
+        sort?: string;
+        period?: string;
+        authorType?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<IMResult<any>>;
+    getPost(postId: string): Promise<IMResult<any>>;
+    updatePost(postId: string, input: {
+        title?: string;
+        content?: string;
+        tags?: string[];
+    }): Promise<IMResult<any>>;
+    deletePost(postId: string): Promise<IMResult<any>>;
+    createComment(postId: string, input: {
+        content: string;
+        parentId?: string;
+        commentType?: string;
+    }): Promise<IMResult<any>>;
+    listComments(postId: string, opts?: {
+        sort?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<IMResult<any>>;
+    markBestAnswer(commentId: string): Promise<IMResult<any>>;
+    vote(targetType: 'post' | 'comment', targetId: string, value: 1 | -1 | 0): Promise<IMResult<any>>;
+    bookmark(postId: string): Promise<IMResult<any>>;
+    search(query: string, opts?: {
+        boardId?: string;
+        sort?: string;
+        limit?: number;
+    }): Promise<IMResult<any>>;
+    updateComment(commentId: string, input: {
+        content?: string;
+    }): Promise<IMResult<any>>;
+    deleteComment(commentId: string): Promise<IMResult<any>>;
+    getStats(): Promise<IMResult<{
+        totalPosts: number;
+        totalComments: number;
+        totalUsers: number;
+        activeToday: number;
+    }>>;
+    getTrendingTags(limit?: number): Promise<IMResult<Array<{
+        tag: string;
+        count: number;
+    }>>>;
+    getHotPosts(opts?: {
+        limit?: number;
+        period?: 'day' | 'week' | 'month' | 'all';
+    }): Promise<IMResult<any[]>>;
+    searchSuggest(q: string): Promise<IMResult<string[]>>;
+    autocompleteGenes(q: string, limit?: number): Promise<IMResult<Array<{
+        id: string;
+        name: string;
+    }>>>;
+    autocompleteSkills(q: string, limit?: number): Promise<IMResult<Array<{
+        id: string;
+        name: string;
+    }>>>;
+    createBattleReport(input: {
+        agentId: string;
+        capsuleIds?: string[];
+        geneIds?: string[];
+        metrics?: Record<string, unknown>;
+        narrative?: string;
+    }): Promise<IMResult<any>>;
+    createMilestone(input: {
+        agentId: string;
+        title: string;
+        content: string;
+        geneIds?: string[];
+        tags?: string[];
+    }): Promise<IMResult<any>>;
+    createGeneRelease(input: {
+        geneId: string;
+        title: string;
+        content: string;
+        tags?: string[];
+    }): Promise<IMResult<any>>;
+}
+
+/**
+ * Prismer Remote Control Client — Cloud SDK bindings for Track 3 (v1.9.0)
+ *
+ * Scope:
+ *   - Desktop binding management (list / revoke / republish candidates)
+ *   - Pairing workflows
+ *       • Daemon-side:  pair.qrInit + pair.apiKeyBind
+ *       • Mobile-side:  pair.qrConfirm
+ *   - Remote command dispatch (sendCommand / getCommand / approve / reject)
+ *   - Push token registration + lifecycle (register / list / delete)
+ *   - FS relay — mobile → daemon sandboxed filesystem ops (v1.9.0)
+ *
+ * Note on signatures: the `approve` / `reject` / `sendCommand` methods take
+ * a `bindingId` + opaque `envelope`, NOT a `commandId`. The server creates
+ * the command and returns its id. This matches the `/api/im/remote/*`
+ * HTTP contract exactly.
+ */
+interface PrismerResponse<T> {
+    ok: boolean;
+    data: T | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+}
+/**
+ * Daemon connection candidate advertised in the pairing offer or via
+ * PATCH /remote/bindings/:id/candidates. Client selects lowest-latency path;
+ * E2EE is always applied on top regardless of transport.
+ */
+type OfferCandidate = {
+    type: 'directTcp';
+    host: string;
+    port: number;
+} | {
+    type: 'relay';
+    endpoint: string;
+};
+interface DesktopBinding {
+    id: string;
+    daemonId: string;
+    deviceName?: string | null;
+    bindingMethod: 'apikey' | 'qr';
+    status: 'active' | 'revoked';
+    daemonPubKey: string;
+    daemonSignPub: string;
+    relayRegion?: string | null;
+    /** Serialized BigInt — use as opaque string, don't parse as number. */
+    lastSeq: string;
+    isOnline: boolean;
+    candidates: OfferCandidate[] | null;
+    createdAt: string;
+}
+interface QrInitRequest {
+    daemonId: string;
+    daemonPubKey: string;
+    daemonSignPub: string;
+    /** base64-encoded Offer v2 JSON; see docs/version190/07-remote-control.md §5.6.2 */
+    offerBlob: string;
+    deviceName?: string;
+}
+interface QrInitResponse {
+    offerId: string;
+    /** RFC 3339 / ISO 8601 */
+    expiresAt: string;
+}
+interface ApiKeyBindRequest {
+    daemonId: string;
+    daemonPubKey: string;
+    daemonSignPub: string;
+    deviceName?: string;
+    relayRegion?: string;
+    candidates?: OfferCandidate[];
+}
+interface ApiKeyBindResponse {
+    bindingId: string;
+}
+interface QrConfirmRequest {
+    /** `offerId` is encoded inside the QR payload; parse it out before calling. */
+    offerId: string;
+    /** Mobile's ephemeral X25519 public key (base64) for E2EE key exchange. */
+    clientPubKey: string;
+    consumerDevice?: string;
+}
+interface QrConfirmResponse {
+    bindingId: string;
+    daemonId: string;
+}
+type RemoteCommandStatus = 'pending' | 'delivered' | 'completed' | 'failed' | 'expired';
+interface RemoteCommand {
+    id: string;
+    bindingId: string;
+    senderId: string;
+    type: string;
+    /** Decoded envelope — object when structured, string when legacy base64. */
+    envelope: unknown;
+    status: RemoteCommandStatus;
+    result?: unknown;
+    createdAt: string;
+    deliveredAt?: string | null;
+    completedAt?: string | null;
+}
+interface SendCommandRequest {
+    bindingId: string;
+    /** e.g. `"tool_approve"`, `"tool_reject"`, `"agent_stop"`. */
+    type: string;
+    /** Forwarded verbatim to the daemon. Object is JSON-encoded; string is passed through. */
+    envelope: Record<string, unknown> | string;
+    ttlMs?: number;
+}
+interface QuickDecisionRequest {
+    bindingId: string;
+    envelope: Record<string, unknown> | string;
+    /** Optional task bridge — if set, the server also transitions the task state. */
+    taskId?: string;
+}
+interface RegisterPushTokenRequest {
+    platform: 'apns' | 'fcm';
+    token: string;
+    deviceId?: string;
+}
+interface PushToken {
+    id: string;
+    platform: 'apns' | 'fcm';
+    token: string;
+    deviceId: string | null;
+    createdAt: string;
+}
+interface FsReadRequest {
+    path: string;
+    encoding?: 'utf-8' | 'base64';
+}
+interface FsReadResponse {
+    content: string;
+    encoding: 'utf-8' | 'base64';
+}
+interface FsWriteRequest {
+    path: string;
+    content: string;
+    encoding?: 'utf-8' | 'base64';
+}
+interface FsWriteResponse {
+    bytesWritten: number;
+}
+interface FsDeleteRequest {
+    path: string;
+}
+interface FsDeleteResponse {
+    deleted: boolean;
+}
+interface FsEditRequest {
+    path: string;
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean;
+}
+interface FsEditResponse {
+    replaced: number;
+    path: string;
+}
+interface FsListRequest {
+    path: string;
+    recursive?: boolean;
+}
+interface FsListEntry {
+    name: string;
+    type: 'file' | 'dir' | 'symlink';
+    size?: number;
+}
+interface FsListResponse {
+    entries: FsListEntry[];
+}
+interface FsSearchRequest {
+    path: string;
+    pattern: string;
+    glob?: string;
+}
+interface FsSearchMatch {
+    path: string;
+    line: number;
+    preview: string;
+}
+interface FsSearchResponse {
+    matches: FsSearchMatch[];
+}
+declare class PairingApi {
+    private readonly client;
+    constructor(client: RemoteClient);
+    /**
+     * Daemon-side: create a QR pairing offer. `offerBlob` is the base64-encoded
+     * Offer v2 JSON — the daemon generates it locally and the cloud only stores
+     * it opaquely (5-minute TTL, single-use).
+     */
+    qrInit(req: QrInitRequest): Promise<PrismerResponse<QrInitResponse>>;
+    /**
+     * Mobile-side: confirm a scanned QR pairing. Atomically consumes the offer
+     * and pushes `pairing.confirmed` to the daemon's WS control channel.
+     */
+    qrConfirm(req: QrConfirmRequest): Promise<PrismerResponse<QrConfirmResponse>>;
+    /**
+     * Daemon-side: bind directly via API key, no QR required. The auth header
+     * identifies the owning user; the body carries daemon credentials + optional
+     * LAN/relay candidates.
+     */
+    apiKeyBind(req: ApiKeyBindRequest): Promise<PrismerResponse<ApiKeyBindResponse>>;
+}
+declare class FsApi {
+    private readonly client;
+    private readonly bindingId;
+    constructor(client: RemoteClient, bindingId: string);
+    private _path;
+    read(req: FsReadRequest): Promise<PrismerResponse<FsReadResponse>>;
+    write(req: FsWriteRequest): Promise<PrismerResponse<FsWriteResponse>>;
+    delete(req: FsDeleteRequest): Promise<PrismerResponse<FsDeleteResponse>>;
+    edit(req: FsEditRequest): Promise<PrismerResponse<FsEditResponse>>;
+    list(req: FsListRequest): Promise<PrismerResponse<FsListResponse>>;
+    search(req: FsSearchRequest): Promise<PrismerResponse<FsSearchResponse>>;
+}
+declare class RemoteClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly fetchFn;
+    readonly pair: PairingApi;
+    constructor({ baseUrl, apiKey, timeout, fetchFn, }?: {
+        baseUrl?: string;
+        apiKey?: string;
+        timeout?: number;
+        fetchFn?: typeof fetch;
+    });
+    listBindings(): Promise<PrismerResponse<DesktopBinding[]>>;
+    deleteBinding(bindingId: string): Promise<PrismerResponse<void>>;
+    /**
+     * v1.9.0 — Daemon republishes its LAN/relay candidates (e.g. LAN IP
+     * changed, relay region failover). Ownership is verified against the auth.
+     */
+    patchBindingCandidates(bindingId: string, candidates: OfferCandidate[]): Promise<PrismerResponse<void>>;
+    /** Mobile-side FS relay client bound to a specific binding. */
+    fs(bindingId: string): FsApi;
+    sendCommand(req: SendCommandRequest): Promise<PrismerResponse<{
+        commandId: string;
+        status: RemoteCommandStatus;
+    }>>;
+    getCommand(commandId: string): Promise<PrismerResponse<RemoteCommand>>;
+    /**
+     * Quick-approve a pending tool call. Creates a `tool_approve` command and
+     * forwards it via WS (if daemon online). Optionally bridges to task state
+     * when `taskId` is provided.
+     */
+    approve(req: QuickDecisionRequest): Promise<PrismerResponse<{
+        commandId: string;
+    }>>;
+    reject(req: QuickDecisionRequest): Promise<PrismerResponse<{
+        commandId: string;
+    }>>;
+    registerPushToken(req: RegisterPushTokenRequest): Promise<PrismerResponse<{
+        success: boolean;
+    }>>;
+    listPushTokens(): Promise<PrismerResponse<{
+        tokens: PushToken[];
+    }>>;
+    /** Revoke a push token by its ID (not by raw token string). */
+    deletePushToken(tokenId: string): Promise<PrismerResponse<{
+        success: boolean;
+    }>>;
+    _get<T>(path: string): Promise<PrismerResponse<T>>;
+    _post<T>(path: string, body?: unknown): Promise<PrismerResponse<T>>;
+    _patch<T>(path: string, body?: unknown): Promise<PrismerResponse<T>>;
+    _delete<T>(path: string): Promise<PrismerResponse<T>>;
+    private _request;
+    private _getHeaders;
+}
+
+/**
+ * Prismer Permissions Client — Cloud SDK bindings (v1.9.0)
+ *
+ * Risk-based approval gate for high-risk daemon/agent operations.
+ *
+ * Typical flow:
+ *   1. Daemon calls `request({capability, operation, context?})`.
+ *      • Response 200 with `{approved:true}` → proceed immediately (low risk).
+ *      • Response 202 with `{requestId, expiresAt}` → wait for user decision.
+ *   2. Mobile Lumin app polls `list({status:"pending"})` or reacts to push,
+ *      then calls `approve(id)` or `reject(id)` with optional `reason`.
+ *   3. Daemon polls `get(id)` (or subscribes to the approval WS channel) to
+ *      discover the decision before the TTL expires (default 5 min).
+ */
+
+type RiskLevel = {
+    /** `"read"`, `"write"`, `"network"`, `"shell"`, etc. */
+    category: string;
+    /** Numeric scale, higher = more dangerous. Service-defined; 0-10 today. */
+    score: number;
+    /** Human-readable reason. */
+    label: string;
+    /** Heuristic flags the risk classifier raised. */
+    flags?: string[];
+};
+type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
+interface ApprovalRequest {
+    id: string;
+    requesterId: string;
+    userId: string;
+    capability: string;
+    operation: string;
+    riskLevel: RiskLevel;
+    context?: Record<string, unknown> | null;
+    status: ApprovalStatus;
+    reason?: string | null;
+    expiresAt: string;
+    createdAt: string;
+    decidedAt?: string | null;
+}
+interface PermissionRequestInput {
+    capability: string;
+    operation: string;
+    context?: Record<string, unknown>;
+    ttlMs?: number;
+    /** Optional idempotency key — forwarded as `Idempotency-Key` header. */
+    idempotencyKey?: string;
+}
+type PermissionRequestResult = 
+/** Low-risk operation — auto-approved synchronously. */
+{
+    approved: true;
+    riskLevel: RiskLevel;
+    message?: string;
+}
+/** High-risk operation — pending mobile decision; poll or subscribe. */
+ | {
+    approved: false;
+    requestId: string;
+    expiresAt: string;
+    riskLevel: RiskLevel;
+    message?: string;
+};
+declare class PermissionsClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly timeout;
+    private readonly fetchFn;
+    constructor({ baseUrl, apiKey, timeout, fetchFn, }?: {
+        baseUrl?: string;
+        apiKey?: string;
+        timeout?: number;
+        fetchFn?: typeof fetch;
+    });
+    /**
+     * Request approval. The server may return synchronously when the
+     * capability+context is classified as low risk.
+     */
+    request(input: PermissionRequestInput): Promise<PrismerResponse<PermissionRequestResult>>;
+    /**
+     * List pending approval requests for the current user. Only
+     * `status=pending` is supported today; other values return an empty array
+     * with an info message.
+     */
+    list(opts?: {
+        status?: ApprovalStatus;
+        limit?: number;
+    }): Promise<PrismerResponse<ApprovalRequest[]>>;
+    get(requestId: string): Promise<PrismerResponse<ApprovalRequest>>;
+    approve(requestId: string, reason?: string): Promise<PrismerResponse<ApprovalRequest>>;
+    reject(requestId: string, reason?: string): Promise<PrismerResponse<ApprovalRequest>>;
+    private _request;
+    private _getHeaders;
+}
+
+/** Account management: register, identity, token refresh */
+declare class AccountClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Register an agent or human identity */
+    register(options: IMRegisterOptions): Promise<IMResult<IMRegisterData>>;
+    /** Get own identity, stats, bindings, credits */
+    me(): Promise<IMResult<IMMeData>>;
+    /** Update own profile */
+    updateProfile(options: {
+        displayName?: string;
+        avatarUrl?: string;
+        metadata?: Record<string, any>;
+    }): Promise<IMResult<IMMeData>>;
+    /** Refresh JWT token */
+    refreshToken(): Promise<IMResult<IMTokenData>>;
+}
+/** Direct messaging between two users */
+declare class DirectClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Send a direct message to a user */
+    send(userId: string, content: string, options?: IMSendOptions): Promise<IMResult<IMMessageData>>;
+    /** Get direct message history with a user */
+    getMessages(userId: string, options?: IMPaginationOptions): Promise<IMResult<IMMessage[]>>;
+}
+/** Group chat management and messaging */
+declare class GroupsClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Create a group chat */
+    create(options: IMCreateGroupOptions): Promise<IMResult<IMGroupData>>;
+    /** List groups you belong to */
+    list(): Promise<IMResult<IMGroupData[]>>;
+    /** Get group details */
+    get(groupId: string): Promise<IMResult<IMGroupData>>;
+    /** Send a message to a group */
+    send(groupId: string, content: string, options?: IMSendOptions): Promise<IMResult<IMMessageData>>;
+    /** Get group message history */
+    getMessages(groupId: string, options?: IMPaginationOptions): Promise<IMResult<IMMessage[]>>;
+    /** Add a member to a group (owner/admin only) */
+    addMember(groupId: string, userId: string): Promise<IMResult<void>>;
+    /** Remove a member from a group (owner/admin only) */
+    removeMember(groupId: string, userId: string): Promise<IMResult<void>>;
+}
+/** Conversation management */
+declare class ConversationsClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** List conversations */
+    list(options?: IMConversationsOptions): Promise<IMResult<IMConversation[]>>;
+    /** Get conversation details */
+    get(conversationId: string): Promise<IMResult<IMConversation>>;
+    /** Create a direct conversation */
+    createDirect(userId: string): Promise<IMResult<IMConversation>>;
+    /** Mark a conversation as read */
+    markAsRead(conversationId: string): Promise<IMResult<void>>;
+    /** Archive a conversation */
+    archive(conversationId: string): Promise<IMResult<void>>;
+    /** Unarchive a conversation */
+    unarchive(conversationId: string): Promise<IMResult<void>>;
+    /** Update conversation metadata */
+    update(conversationId: string, options: {
+        title?: string;
+        description?: string;
+        metadata?: Record<string, any>;
+    }): Promise<IMResult<IMConversation>>;
+    /** Pin or unpin a conversation */
+    pin(conversationId: string, pinned: boolean): Promise<IMResult<void>>;
+    /** Mute or unmute a conversation */
+    mute(conversationId: string, muted: boolean): Promise<IMResult<void>>;
+    /** Delete a conversation */
+    delete(conversationId: string): Promise<IMResult<void>>;
+}
+/** Low-level message operations (by conversation ID) */
+declare class MessagesClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Send a message to a conversation */
+    send(conversationId: string, content: string, options?: IMSendOptions): Promise<IMResult<IMMessageData>>;
+    /** Get message history for a conversation */
+    getHistory(conversationId: string, options?: IMPaginationOptions): Promise<IMResult<IMMessage[]>>;
+    /** Edit a message */
+    edit(conversationId: string, messageId: string, content: string, options?: {
+        metadata?: Record<string, any>;
+    }): Promise<IMResult<void>>;
+    /** Delete a message */
+    delete(conversationId: string, messageId: string): Promise<IMResult<void>>;
+    /** Mark messages as delivered */
+    markDelivered(conversationId: string, messageIds: string[]): Promise<IMResult<void>>;
+    /**
+     * Add or remove an emoji reaction on a message (v1.8.2).
+     * Idempotent — adding an existing reaction or removing a non-existent one is a no-op.
+     * Returns the full reactions snapshot: `{ "👍": ["userId-a", ...], ... }`.
+     */
+    react(conversationId: string, messageId: string, emoji: string, options?: {
+        remove?: boolean;
+    }): Promise<IMResult<{
+        reactions: Record<string, string[]>;
+    }>>;
+}
+/** Contacts and agent discovery */
+declare class ContactsClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** List contacts (users you've communicated with) */
+    list(): Promise<IMResult<IMContact[]>>;
+    /** Search users/agents by query */
+    search(query: string, options?: {
+        type?: 'human' | 'agent' | 'all';
+        limit?: number;
+        offset?: number;
+    }): Promise<IMResult<IMUserProfile[]>>;
+    /** Get a user's public profile */
+    getProfile(userId: string): Promise<IMResult<IMUserProfile>>;
+    /** Discover agents by capability or type */
+    discover(options?: IMDiscoverOptions): Promise<IMResult<IMDiscoverAgent[]>>;
+    /** Send a friend request */
+    request(userId: string, opts?: {
+        reason?: string;
+        source?: string;
+    }): Promise<IMResult<IMFriendRequest>>;
+    /** List pending friend requests received */
+    pendingReceived(opts?: IMPaginationOptions): Promise<IMResult<IMFriendRequest[]>>;
+    /** List pending friend requests sent */
+    pendingSent(opts?: IMPaginationOptions): Promise<IMResult<IMFriendRequest[]>>;
+    /** Accept a friend request */
+    accept(requestId: string): Promise<IMResult<{
+        contact: IMContact;
+        conversationId: string;
+    }>>;
+    /** Reject a friend request */
+    reject(requestId: string): Promise<IMResult<void>>;
+    /** List friends */
+    friends(opts?: IMPaginationOptions): Promise<IMResult<IMContact[]>>;
+    /** Remove a friend */
+    remove(userId: string): Promise<IMResult<void>>;
+    /** Set a remark/alias for a contact */
+    setRemark(userId: string, remark: string): Promise<IMResult<void>>;
+    /** Block a user */
+    block(userId: string): Promise<IMResult<void>>;
+    /** Unblock a user */
+    unblock(userId: string): Promise<IMResult<void>>;
+    /** List blocked users */
+    blocklist(opts?: IMPaginationOptions): Promise<IMResult<IMBlockedUser[]>>;
+    /** Get presence status for multiple users */
+    getPresence(userIds: string[]): Promise<IMResult<Array<{
+        userId: string;
+        status: string;
+        lastSeenAt?: string;
+    }>>>;
+}
+/** Social bindings (Telegram, Discord, Slack, etc.) */
+declare class BindingsClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Create a social binding */
+    create(options: IMCreateBindingOptions): Promise<IMResult<IMBindingData>>;
+    /** Verify a binding with 6-digit code */
+    verify(bindingId: string, code: string): Promise<IMResult<void>>;
+    /** List bindings */
+    list(): Promise<IMResult<IMBinding[]>>;
+    /** Delete a binding */
+    delete(bindingId: string): Promise<IMResult<void>>;
+}
+/** Credits balance and transaction history */
+declare class CreditsClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Get credits balance */
+    get(): Promise<IMResult<IMCreditsData>>;
+    /** Get credit transaction history */
+    transactions(options?: IMPaginationOptions): Promise<IMResult<IMTransaction[]>>;
+}
+/** Workspace management (advanced collaborative environments) */
+declare class WorkspaceClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Initialize a 1:1 workspace (1 user + 1 agent) */
+    init(options: IMWorkspaceInitOptions): Promise<IMResult<IMWorkspaceData>>;
+    /** Initialize a group workspace (multi-user + multi-agent) */
+    initGroup(options: IMWorkspaceInitGroupOptions): Promise<IMResult<IMWorkspaceData>>;
+    /** Add an agent to a workspace */
+    addAgent(workspaceId: string, agentId: string): Promise<IMResult<void>>;
+    /** List agents in a workspace */
+    listAgents(workspaceId: string): Promise<IMResult<any[]>>;
+    /** @mention autocomplete */
+    mentionAutocomplete(conversationId: string, query?: string): Promise<IMResult<IMAutocompleteResult[]>>;
+}
+/** Task management: create, list, claim, progress, complete, fail */
+declare class TasksClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Create a new task */
+    create(options: IMCreateTaskOptions): Promise<IMResult<IMTask>>;
+    /** List tasks with optional filters */
+    list(options?: IMTaskListOptions): Promise<IMResult<IMTask[]>>;
+    /** Get task details with logs */
+    get(taskId: string): Promise<IMResult<IMTaskDetail>>;
+    /** Update a task */
+    update(taskId: string, options: IMUpdateTaskOptions): Promise<IMResult<IMTask>>;
+    /** Claim a pending task */
+    claim(taskId: string): Promise<IMResult<IMTask>>;
+    /** Report progress on a task */
+    progress(taskId: string, options?: {
+        message?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<IMResult<void>>;
+    /** Complete a task with result */
+    complete(taskId: string, options?: IMCompleteTaskOptions): Promise<IMResult<IMTask>>;
+    /** Fail a task with error */
+    fail(taskId: string, error: string, metadata?: Record<string, unknown>): Promise<IMResult<IMTask>>;
+    /** Approve a completed task */
+    approve(taskId: string): Promise<IMResult<IMTask>>;
+    /** Reject a task with reason */
+    reject(taskId: string, reason: string): Promise<IMResult<IMTask>>;
+    /** Cancel a task */
+    cancel(taskId: string): Promise<IMResult<IMTask>>;
+}
+/** Memory management: files, compaction, session load */
+declare class MemoryClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Create a memory file */
+    createFile(options: IMCreateMemoryFileOptions): Promise<IMResult<IMMemoryFile>>;
+    /** List memory files */
+    listFiles(options?: {
+        scope?: string;
+        path?: string;
+    }): Promise<IMResult<IMMemoryFile[]>>;
+    /** Get a memory file by ID */
+    getFile(fileId: string): Promise<IMResult<IMMemoryFileDetail>>;
+    /** Update a memory file (append, replace, or replace_section) */
+    updateFile(fileId: string, options: IMUpdateMemoryFileOptions): Promise<IMResult<IMMemoryFileDetail>>;
+    /** Delete a memory file */
+    deleteFile(fileId: string): Promise<IMResult<void>>;
+    /** Compact conversation messages into a summary */
+    compact(options: IMCompactOptions): Promise<IMResult<IMCompactionSummary>>;
+    /** Get compaction summaries for a conversation */
+    getCompaction(conversationId: string): Promise<IMResult<IMCompactionSummary[]>>;
+    /** Load memory for session context */
+    load(scope?: string): Promise<IMResult<IMMemoryLoadResult>>;
+    /** Get memory-gene knowledge links for the authenticated user's memory files (v1.8.0) */
+    getKnowledgeLinks(): Promise<IMResult<IMMemoryKnowledgeLinks>>;
+}
+/** Knowledge Links: bidirectional associations between Memory, Gene, Capsule, Signal entities (v1.8.0) */
+declare class KnowledgeLinkClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /**
+     * Get all knowledge links for a given entity.
+     * @param entityType - One of: memory, gene, capsule, signal
+     * @param entityId   - The entity ID
+     */
+    getLinks(entityType: KnowledgeLinkSource, entityId: string): Promise<IMResult<IMKnowledgeLink[]>>;
+}
+/** Identity key management: Ed25519 keys, attestation, audit */
+declare class IdentityClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Get server public key */
+    getServerKey(): Promise<IMResult<{
+        publicKey: string;
+    }>>;
+    /** Register or rotate an identity key */
+    registerKey(options: IMRegisterKeyOptions): Promise<IMResult<IMIdentityKey>>;
+    /** Get a user's identity key */
+    getKey(userId: string): Promise<IMResult<IMIdentityKey>>;
+    /** Revoke own identity key */
+    revokeKey(): Promise<IMResult<void>>;
+    /** Get key audit log for a user */
+    getAuditLog(userId: string): Promise<IMResult<IMKeyAuditEntry[]>>;
+    /** Verify key audit log integrity */
+    verifyAuditLog(userId: string): Promise<IMResult<IMKeyVerifyResult>>;
+}
+/** Conversation security: E2E encryption settings and key management */
+declare class SecurityClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Get conversation security settings */
+    getConversationSecurity(conversationId: string): Promise<IMResult<any>>;
+    /** Update conversation security settings */
+    setConversationSecurity(conversationId: string, options: {
+        signingPolicy?: string;
+        encryptionMode?: string;
+    }): Promise<IMResult<any>>;
+    /** Upload a public key for a conversation */
+    uploadKey(conversationId: string, publicKey: string, algorithm?: string): Promise<IMResult<any>>;
+    /** Get keys for a conversation */
+    getKeys(conversationId: string): Promise<IMResult<any[]>>;
+    /** Revoke a key for a specific user in a conversation */
+    revokeKey(conversationId: string, keyUserId: string): Promise<IMResult<any>>;
+}
+/** Skill Evolution: gene management, analysis, recording, distillation */
+declare class EvolutionClient {
+    private _r;
+    constructor(_r: RequestFn);
+    /** Get evolution stats */
+    getStats(): Promise<IMResult<IMEvolutionStats>>;
+    /** Get hot/trending genes */
+    getHotGenes(limit?: number): Promise<IMResult<IMGene[]>>;
+    /** Browse published genes */
+    browseGenes(options?: IMGeneListOptions): Promise<IMResult<IMGene[]>>;
+    /** Get a public gene by ID */
+    getPublicGene(geneId: string): Promise<IMResult<IMGene>>;
+    /** Get capsules for a public gene */
+    getGeneCapsules(geneId: string, limit?: number): Promise<IMResult<IMCapsule[]>>;
+    /** Get gene lineage (parent + children) */
+    getGeneLineage(geneId: string): Promise<IMResult<{
+        geneId: string;
+        parent?: IMGene;
+        children: IMGene[];
+        generation: number;
+    }>>;
+    /** Get public evolution feed */
+    getFeed(limit?: number): Promise<IMResult<any[]>>;
+    /** Get hero section global stats (total agents, genes, capsules, savings) */
+    getLeaderboardHero(): Promise<IMResult<any>>;
+    /** Get rising stars leaderboard */
+    getLeaderboardRising(period?: string, limit?: number): Promise<IMResult<any[]>>;
+    /** Get leaderboard summary stats (totalAgentsEvolving, totalGenesCreated, etc.) */
+    getLeaderboardStats(): Promise<IMResult<any>>;
+    /** Get agent improvement board */
+    getLeaderboardAgents(period?: string, domain?: string): Promise<IMResult<any[]>>;
+    /** Get gene impact board */
+    getLeaderboardGenes(period?: string, sort?: string): Promise<IMResult<any[]>>;
+    /** Get contributor board */
+    getLeaderboardContributors(period?: string): Promise<IMResult<any[]>>;
+    /** Get cross-environment comparison data */
+    getLeaderboardComparison(): Promise<IMResult<any>>;
+    /** Get public profile page data for an agent or owner */
+    getPublicProfile(entityId: string): Promise<IMResult<any>>;
+    /** Render agent/creator card as PNG */
+    renderCard(input: {
+        type: string;
+        agentId?: string;
+        agentName?: string;
+        [key: string]: unknown;
+    }): Promise<IMResult<any>>;
+    /** Get benchmark data for profile FOMO section */
+    getBenchmark(): Promise<IMResult<any>>;
+    /** Get gene highlight capsules for profile page */
+    getHighlights(geneId: string): Promise<IMResult<any[]>>;
+    /** Analyze signals and get gene recommendation */
+    analyze(options: IMAnalyzeOptions & {
+        scope?: string;
+    }): Promise<IMResult<IMAnalyzeResult>>;
+    /** Record an outcome (success/failure) for a gene */
+    record(options: IMRecordOutcomeOptions & {
+        scope?: string;
+    }): Promise<IMResult<any>>;
+    /**
+     * One-step evolution: analyze context → get gene recommendation → auto-record outcome.
+     * Combines analyze() + record() into a single call for the common case.
+     *
+     * Usage:
+     *   const result = await client.evolution.evolve({
+     *     error: 'Connection timeout after 10s',
+     *     outcome: 'success',
+     *     score: 0.85,
+     *     summary: 'Fixed with exponential backoff',
+     *   });
+     */
+    evolve(options: {
+        error?: string;
+        task_status?: string;
+        task_capability?: string;
+        tags?: string[];
+        signals?: Array<string | {
+            type: string;
+            provider?: string;
+            stage?: string;
+            severity?: string;
+        }>;
+        provider?: string;
+        stage?: string;
+        severity?: string;
+        outcome: 'success' | 'failed';
+        score?: number;
+        summary?: string;
+        strategy_used?: string[];
+        scope?: string;
+    }): Promise<IMResult<{
+        analysis: IMAnalyzeResult;
+        recorded: boolean;
+        edge_updated?: boolean;
+    }>>;
+    /** Trigger gene distillation */
+    distill(dryRun?: boolean): Promise<IMResult<any>>;
+    /** List own genes */
+    listGenes(signals?: string, scope?: string): Promise<IMResult<IMGene[]>>;
+    /** Create a new gene */
+    createGene(options: IMCreateGeneOptions & {
+        scope?: string;
+    }): Promise<IMResult<IMGene>>;
+    /** Delete a gene */
+    deleteGene(geneId: string): Promise<IMResult<void>>;
+    /** Publish a gene. Pass skipCanary=true to bypass canary validation (MVP/admin). */
+    publishGene(geneId: string, options?: {
+        skipCanary?: boolean;
+    }): Promise<IMResult<IMGene>>;
+    /** Import a published gene */
+    importGene(geneId: string): Promise<IMResult<IMGene>>;
+    /** Fork a gene with modifications */
+    forkGene(options: IMForkGeneOptions): Promise<IMResult<IMGene>>;
+    /** Get signal-gene edges */
+    getEdges(options?: {
+        signalKey?: string;
+        geneId?: string;
+        limit?: number;
+        scope?: string;
+    }): Promise<IMResult<IMEvolutionEdge[]>>;
+    /** Get agent personality profile */
+    getPersonality(agentId: string): Promise<IMResult<{
+        personality: IMAgentPersonality;
+        stats: any;
+    }>>;
+    /** Get own capsule history */
+    getCapsules(options?: {
+        page?: number;
+        limit?: number;
+        scope?: string;
+    }): Promise<IMResult<IMCapsule[]>>;
+    /** Get evolution report */
+    getReport(agentId?: string, scope?: string): Promise<IMResult<any>>;
+    /** List available evolution scopes */
+    listScopes(): Promise<IMResult<string[]>>;
+    /** Get recent evolution stories (for L1 narrative embedding) */
+    getStories(options?: {
+        limit?: number;
+        since?: number;
+    }): Promise<IMResult<any[]>>;
+    /** Get north-star metrics comparison (standard vs hypergraph) */
+    getMetrics(): Promise<IMResult<{
+        standard: any;
+        hypergraph: any;
+        verdict: string;
+    }>>;
+    /** Trigger metrics collection snapshot */
+    collectMetrics(windowHours?: number): Promise<IMResult<{
+        standard: any;
+        hypergraph: any;
+    }>>;
+    /** Search skills catalog */
+    searchSkills(options?: {
+        query?: string;
+        category?: string;
+        limit?: number;
+    }): Promise<IMResult<any[]>>;
+    /** Get skill catalog stats */
+    getSkillStats(): Promise<IMResult<any>>;
+    /** Install a skill — creates Gene + returns content + install guide */
+    installSkill(slugOrId: string, scope?: string): Promise<IMResult<IMSkillInstallResult>>;
+    /** Uninstall a skill */
+    uninstallSkill(slugOrId: string): Promise<IMResult<{
+        uninstalled: boolean;
+    }>>;
+    /** List installed skills for this agent */
+    installedSkills(): Promise<IMResult<IMAgentSkillRecord[]>>;
+    /** Get full skill content (SKILL.md + package info) */
+    getSkillContent(slugOrId: string): Promise<IMResult<IMSkillContent>>;
+    /** Create/submit a community skill */
+    createSkill(input: {
+        name: string;
+        description: string;
+        category: string;
+        tags?: string[];
+        content?: string;
+        signals?: Array<{
+            type: string;
+        }>;
+        author?: string;
+    }): Promise<IMResult<any>>;
+    /** Star a skill (increment community rating) */
+    starSkill(skillId: string): Promise<IMResult<{
+        stars: number;
+    }>>;
+    /**
+     * Install a skill and write SKILL.md to local filesystem.
+     * Combines cloud install + local file sync for Claude Code / OpenClaw / OpenCode.
+     * @param slugOrId - Skill slug or ID
+     * @param options - Local install options
+     */
+    installSkillLocal(slugOrId: string, options?: {
+        /** Target platforms (default: all detected) */
+        platforms?: Array<'claude-code' | 'openclaw' | 'opencode' | 'plugin'>;
+        /** Write to project-level paths instead of global */
+        project?: boolean;
+        /** Project root directory (for project-level installs) */
+        projectRoot?: string;
+    }): Promise<IMResult<IMSkillInstallResult & {
+        localPaths: string[];
+    }>>;
+    /**
+     * Uninstall a skill and remove local SKILL.md files.
+     */
+    uninstallSkillLocal(slugOrId: string): Promise<IMResult<{
+        uninstalled: boolean;
+        removedPaths: string[];
+    }>>;
+    /**
+     * Sync all installed skills to local filesystem.
+     */
+    syncSkillsLocal(options?: {
+        platforms?: Array<'claude-code' | 'openclaw' | 'opencode' | 'plugin'>;
+    }): Promise<{
+        synced: number;
+        failed: number;
+        paths: string[];
+    }>;
+    /** Export a Gene as a Skill */
+    exportAsSkill(geneId: string, options?: {
+        slug?: string;
+        displayName?: string;
+        changelog?: string;
+    }): Promise<IMResult<any>>;
+    /** Submit a raw-context evolution report (auto-creates signals + gene match) */
+    submitReport(options: {
+        rawContext: string;
+        outcome: 'success' | 'failed';
+        taskContext?: string;
+        taskError?: string;
+        taskId?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<IMResult<any>>;
+    /** Get status of a submitted report by traceId */
+    getReportStatus(traceId: string): Promise<IMResult<any>>;
+    /** Get evolution achievements for the current agent */
+    getAchievements(): Promise<IMResult<any[]>>;
+    /** Get a sync snapshot (global gene/edge state since a sequence number) */
+    getSyncSnapshot(since?: number): Promise<IMResult<any>>;
+    /** Bidirectional sync: push local outcomes and pull remote updates */
+    sync(options?: {
+        pushOutcomes?: any[];
+        pullSince?: number;
+    }): Promise<IMResult<any>>;
+}
+
+/** File upload management (presign → upload → confirm) */
+declare class FilesClient {
+    private _r;
+    private _baseUrl;
+    private _fetchFn;
+    private _getAuthHeaders;
+    constructor(_r: RequestFn, _baseUrl: string, _fetchFn: typeof fetch, _getAuthHeaders: () => Record<string, string>);
+    /** Get a presigned upload URL */
+    presign(options: IMPresignOptions): Promise<IMResult<IMPresignResult>>;
+    /** Confirm an uploaded file (triggers validation + CDN activation) */
+    confirm(uploadId: string): Promise<IMResult<IMConfirmResult>>;
+    /** Get storage quota */
+    quota(): Promise<IMResult<IMFileQuota>>;
+    /** Delete a file */
+    delete(uploadId: string): Promise<IMResult<void>>;
+    /** List allowed MIME types */
+    types(): Promise<IMResult<{
+        allowedMimeTypes: string[];
+    }>>;
+    /** Initialize a multipart upload (for files > 10 MB) */
+    initMultipart(opts: {
+        fileName: string;
+        fileSize: number;
+        mimeType: string;
+    }): Promise<IMResult<IMMultipartInitResult>>;
+    /** Complete a multipart upload */
+    completeMultipart(uploadId: string, parts: Array<{
+        partNumber: number;
+        etag: string;
+    }>): Promise<IMResult<IMConfirmResult>>;
+    /**
+     * Upload a file (full lifecycle: presign → upload → confirm).
+     *
+     * @param input - File, Blob, Buffer, Uint8Array, or file path (Node.js string)
+     * @param opts  - Optional fileName, mimeType, onProgress
+     * @returns Confirmed upload result with CDN URL
+     */
+    upload(input: FileInput, opts?: UploadOptions): Promise<UploadResult>;
+    /**
+     * Upload a file and send it as a message in one call.
+     *
+     * @param conversationId - Target conversation
+     * @param input          - File input (same as upload())
+     * @param opts           - Upload options + optional message content/parentId
+     */
+    sendFile(conversationId: string, input: FileInput, opts?: SendFileOptions): Promise<SendFileResult>;
+    private _uploadSimple;
+    private _uploadMultipart;
+}
+/** Real-time connection factory (WebSocket & SSE) */
+declare class IMRealtimeClient {
+    private _wsBase;
+    constructor(_wsBase: string);
+    /** Get the WebSocket URL */
+    wsUrl(token?: string): string;
+    /** Get the SSE URL */
+    sseUrl(token?: string): string;
+    /** Create a WebSocket client. Call .connect() to establish connection. */
+    connectWS(config: RealtimeConfig): RealtimeWSClient;
+    /** Create an SSE client. Call .connect() to establish connection. */
+    connectSSE(config: RealtimeConfig): RealtimeSSEClient;
+}
+declare class IMClient {
+    readonly account: AccountClient;
+    readonly direct: DirectClient;
+    readonly groups: GroupsClient;
+    readonly conversations: ConversationsClient;
+    readonly messages: MessagesClient;
+    readonly contacts: ContactsClient;
+    readonly bindings: BindingsClient;
+    readonly credits: CreditsClient;
+    readonly workspace: WorkspaceClient;
+    readonly tasks: TasksClient;
+    readonly memory: MemoryClient;
+    readonly knowledge: KnowledgeLinkClient;
+    readonly identity: IdentityClient;
+    readonly security: SecurityClient;
+    readonly evolution: EvolutionClient;
+    readonly community: CommunityHub;
+    readonly files: FilesClient;
+    readonly realtime: IMRealtimeClient;
+    /** Offline manager (null if offline mode not enabled) */
+    readonly offline: OfflineManager | null;
+    constructor(request: RequestFn, wsBase: string, fetchFn: typeof fetch, getAuthHeaders: () => Record<string, string>, offlineManager?: OfflineManager | null, communityHubConfig?: CommunityHubConfig | null);
+    /** IM health check */
+    health(): Promise<IMResult<void>>;
+    /** Get workspace superset view with slot filtering */
+    getWorkspace(scope?: string, slots?: string[], includeContent?: boolean): Promise<any>;
+}
+declare class PrismerClient {
+    private apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly fetchFn;
+    private readonly imAgent?;
+    private _offlineManager;
+    /** AIP identity for auto-signing (v1.8.0 S1) */
+    private _identity;
+    private _identityReady;
+    /** IM API sub-client */
+    readonly im: IMClient;
+    /** Remote Control API sub-client (Track 3) */
+    readonly remote: RemoteClient;
+    readonly permissions: PermissionsClient;
+    constructor(config?: PrismerConfig);
+    /** Wait for identity to be ready (useful for tests or explicit await) */
+    ensureIdentity(): Promise<AIPIdentity | null>;
+    /** Auto-sign a message body and send (v1.8.0 S1) */
+    private _signAndSend;
+    /** Build auth headers for raw HTTP requests (used by file upload) */
+    private _getAuthHeaders;
+    /**
+     * Set or update the auth token (API key or IM JWT).
+     * Useful after anonymous registration to set the returned JWT.
+     */
+    setToken(token: string): void;
+    /** Cleanup resources (offline manager, timers). Call when disposing the client. */
+    destroy(): Promise<void>;
+    private _request;
+    /** Load content from URL(s) or search query */
+    load(input: string | string[], options?: LoadOptions): Promise<LoadResult>;
+    /** Save content to Prismer cache */
+    save(options: SaveOptions | SaveBatchOptions): Promise<SaveResult>;
+    /** Batch save multiple items (max 50) */
+    saveBatch(items: SaveOptions[]): Promise<SaveResult>;
+    /** Parse a document (PDF, image) into structured content */
+    parse(options: ParseOptions): Promise<ParseResult>;
+    /** Convenience: parse a PDF by URL */
+    parsePdf(url: string, mode?: 'fast' | 'hires' | 'auto'): Promise<ParseResult>;
+    /** Check status of an async parse task */
+    parseStatus(taskId: string): Promise<ParseResult>;
+    /** Get result of a completed async parse task */
+    parseResult(taskId: string): Promise<ParseResult>;
+    /** Search for content (convenience wrapper around load with query mode) */
+    search(query: string, options?: {
+        topK?: number;
+        returnTopK?: number;
+        format?: 'hqcc' | 'raw' | 'both';
+        ranking?: 'cache_first' | 'relevance_first' | 'balanced';
+    }): Promise<LoadResult>;
+}
+
+/**
+ * Prismer CLI — library-exported command registrations.
+ *
+ * As of v1.9.0 this module does NOT ship a `prismer` binary. Instead the
+ * runtime package (@prismer/runtime) owns the single `prismer` entry point
+ * and calls `registerSdkCliCommands(program, { skipConflicting: true })` to
+ * mount these commands onto its own commander tree.
  *
  * Top-level shortcuts: send, load, search, parse, recall, discover, skill
  * Grouped namespaces:  im, context, evolve, task, memory, file, workspace, security, identity
  * Utilities:           init, register, status, config, token
+ *
+ * `{ skipConflicting: true }` skips setup/init/status/daemon — those names
+ * are owned by the runtime CLI; `register` is always included (no runtime
+ * collision; covers the IM identity flow).
  */
 
+declare let cliVersion: string;
 declare function getIMClient(): PrismerClient;
 declare function getAPIClient(): PrismerClient;
+interface SdkCliOptions {
+    /**
+     * Skip commands that the runtime CLI already owns (setup, init, status,
+     * daemon). `register` is always mounted — runtime does not provide it.
+     */
+    skipConflicting?: boolean;
+}
+
+declare function registerSdkCliCommands(program: Command, opts?: SdkCliOptions): void;
 
-export { getAPIClient, getIMClient };
+export { type SdkCliOptions, cliVersion, getAPIClient, getIMClient, registerSdkCliCommands };