@prismer/sdk 1.7.0 → 1.7.3

package/dist/index.d.mts

@@ -36,6 +36,19 @@ interface MessageNewPayload {
     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;
+}
 interface TypingIndicatorPayload {
     conversationId: string;
     userId: string;
@@ -62,6 +75,8 @@ interface ReconnectingPayload {
 interface RealtimeEventMap {
     'authenticated': AuthenticatedPayload;
     'message.new': MessageNewPayload;
+    'message.edit': MessageEditPayload;
+    'message.deleted': MessageDeletedPayload;
     'typing.indicator': TypingIndicatorPayload;
     'presence.changed': PresenceChangedPayload;
     'pong': PongPayload;
@@ -122,7 +137,11 @@ declare class RealtimeWSClient extends TypedEmitter {
     connect(): Promise<void>;
     disconnect(code?: number, reason?: string): void;
     joinConversation(conversationId: string): void;
-    sendMessage(conversationId: string, content: string, type?: 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;
@@ -913,8 +932,410 @@ interface OfflineConfig {
         warningThreshold?: number;
     };
 }
+type TaskStatus = 'pending' | 'assigned' | 'running' | '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 {
+    assigneeId?: string;
+    status?: TaskStatus;
+    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;
+    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 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>;
+interface ExecutionContext {
+    error?: string;
+    provider?: string;
+    stage?: string;
+    severity?: string;
+    taskStatus?: string;
+    taskCapability?: string;
+    tags?: string[];
+    [key: string]: unknown;
+}
+interface SignalEnrichmentConfig {
+    mode: 'rules' | 'llm';
+    llmExtract?: (ctx: ExecutionContext) => Promise<SignalTag[]>;
+    timeoutMs?: number;
+    cacheTtlMs?: number;
+}
+interface GeneSelectionResult {
+    action: 'apply_gene' | 'create_suggested' | 'none';
+    gene_id?: string;
+    gene?: IMGene;
+    strategy?: string[];
+    confidence: number;
+    coverageScore?: number;
+    alternatives?: Array<{
+        gene_id: string;
+        confidence: number;
+        title?: string;
+    }>;
+    reason?: string;
+    fromCache: boolean;
+}
+interface EvolutionSyncSnapshot {
+    genes: IMGene[];
+    edges: IMEvolutionEdge[];
+    globalPrior: Record<string, {
+        alpha: number;
+        beta: number;
+    }>;
+    cursor: number;
+}
+interface EvolutionSyncDelta {
+    pulled: {
+        genes: IMGene[];
+        edges: IMEvolutionEdge[];
+        globalPrior: Record<string, {
+            alpha: number;
+            beta: number;
+        }>;
+        promotions: string[];
+        quarantines: string[];
+        cursor: number;
+    };
+}
 
 /**
  * Prismer SDK — Offline Manager, Outbox Queue, and Sync Engine.
@@ -1245,6 +1666,318 @@ declare class E2EEncryption {
     destroy(): void;
 }
 
+/**
+ * Encryption Pipeline — wraps message send/receive with automatic E2E.
+ *
+ * This is a HELPER module — it does not modify existing client behavior.
+ * Users opt-in by calling pipeline functions explicitly before send / after receive.
+ *
+ * Usage:
+ *   import { E2EEncryption } from '@prismer/sdk';
+ *   import { encryptForSend, decryptOnReceive } from '@prismer/sdk';
+ *
+ *   const e2e = new E2EEncryption();
+ *   await e2e.init('passphrase');
+ *   await e2e.generateSessionKey('conv-123');
+ *
+ *   // Before sending
+ *   const enc = await encryptForSend(e2e, 'conv-123', 'Hello!');
+ *   await client.im.messages.send('conv-123', enc.content, { metadata: enc.metadata });
+ *
+ *   // After receiving
+ *   const dec = await decryptOnReceive(e2e, msg.conversationId, msg.content, msg.metadata);
+ *   if (dec.decrypted) console.log('Plaintext:', dec.content);
+ */
+
+interface EncryptedMessage {
+    content: string;
+    metadata: Record<string, unknown>;
+}
+interface DecryptResult {
+    content: string;
+    decrypted: boolean;
+    error?: string;
+}
+interface EncryptedFileResult {
+    data: string;
+    metadata: {
+        encrypted: true;
+        encKeyId: string;
+    };
+}
+interface EncryptedContextResult {
+    content: string;
+    encrypted: true;
+}
+/**
+ * Encrypt a message before sending.
+ * Returns modified content + metadata with encrypted flag.
+ *
+ * If no session key exists for the conversation, returns plaintext unchanged.
+ */
+declare function encryptForSend(e2e: E2EEncryption, conversationId: string, content: string, metadata?: Record<string, unknown>): Promise<EncryptedMessage>;
+/**
+ * Decrypt a received message.
+ * Returns the plaintext content, or the original content if:
+ * - The message is not encrypted (metadata.encrypted !== true)
+ * - No session key is available for the conversation
+ * - Decryption fails (returns original content + error string)
+ */
+declare function decryptOnReceive(e2e: E2EEncryption, conversationId: string, content: string, metadata?: Record<string, unknown>): Promise<DecryptResult>;
+/**
+ * Encrypt a file buffer before upload.
+ *
+ * Converts the file bytes to base64, encrypts as text using the conversation
+ * session key, and returns the ciphertext string + metadata.
+ *
+ * Returns null if no session key exists for the conversation.
+ *
+ * Note: File size increases ~33% due to base64 encoding + GCM overhead.
+ * The server stores opaque bytes and cannot inspect the content.
+ */
+declare function encryptFile(e2e: E2EEncryption, conversationId: string, data: Uint8Array): Promise<EncryptedFileResult | null>;
+/**
+ * Decrypt a file that was encrypted with encryptFile().
+ *
+ * Returns the original file bytes, or null if no session key or decryption fails.
+ */
+declare function decryptFile(e2e: E2EEncryption, conversationId: string, ciphertext: string): Promise<Uint8Array | null>;
+/**
+ * Encrypt context cache content (HQCC) before saving.
+ *
+ * Uses a special context ID for key management (default: 'context-cache').
+ * The agent must have a session key for this context ID — generate one with:
+ *   await e2e.generateSessionKey('context-cache');
+ *
+ * Returns null if no session key exists.
+ *
+ * Note: Encrypted context CANNOT be server-side compressed or indexed.
+ * The HQCC field becomes opaque. Agents must handle their own compression
+ * before encryption.
+ */
+declare function encryptContext(e2e: E2EEncryption, content: string, contextId?: string): Promise<EncryptedContextResult | null>;
+/**
+ * Decrypt context cache content that was encrypted with encryptContext().
+ *
+ * Returns the plaintext HQCC, or null if no session key or decryption fails.
+ */
+declare function decryptContext(e2e: E2EEncryption, ciphertext: string, contextId?: string): Promise<string | null>;
+/**
+ * Decrypt an array of messages in-place (mutates the array).
+ * Useful for processing message history after fetching.
+ *
+ * Returns the count of successfully decrypted messages.
+ */
+declare function decryptMessages<T extends {
+    conversationId?: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+}>(e2e: E2EEncryption, messages: T[], conversationId?: string): Promise<{
+    decryptedCount: number;
+    errors: Array<{
+        index: number;
+        error: string;
+    }>;
+}>;
+
+/**
+ * EvolutionCache — local gene cache with Thompson Sampling selection.
+ * Enables <1ms gene selection without network calls.
+ */
+
+declare class EvolutionCache {
+    private _genes;
+    private _edges;
+    private _globalPrior;
+    private _cursor;
+    get cursor(): number;
+    get geneCount(): number;
+    /** Load from a full snapshot */
+    loadSnapshot(snapshot: EvolutionSyncSnapshot): void;
+    /** Apply incremental delta (alias: loadDelta) */
+    applyDelta(delta: EvolutionSyncDelta): void;
+    /** Apply incremental delta (alias for applyDelta) */
+    loadDelta(delta: EvolutionSyncDelta): void;
+    /** Select best gene locally using Thompson Sampling — pure CPU, <1ms */
+    selectGene(signals: SignalTag[]): GeneSelectionResult;
+}
+
+/**
+ * Signal Enrichment Layer — SDK-side signal extraction.
+ * Migrated from server's signal-extractor.ts regex patterns.
+ * Supports pure-rules mode (zero deps) and optional LLM injection.
+ */
+
+/**
+ * Extract signals from execution context using regex rules.
+ * Zero dependencies, synchronous, <0.1ms.
+ */
+declare function extractSignals(ctx: ExecutionContext): SignalTag[];
+/**
+ * Create an enriched signal extractor with optional LLM injection.
+ * LLM mode: calls the agent's LLM for high-precision extraction.
+ * Falls back to rules mode on timeout or error.
+ */
+declare function createEnrichedExtractor(config: SignalEnrichmentConfig): (ctx: ExecutionContext) => Promise<SignalTag[]>;
+
+/**
+ * EvolutionRuntime — High-level evolution API for agents.
+ *
+ * Composes EvolutionCache + SignalEnrichment + async outbox into two simple methods:
+ *   - suggest(error, context?) → strategy recommendation (<1ms local, fallback to server)
+ *   - learned(error, outcome, summary, geneId?) → fire-and-forget outcome recording
+ *
+ * Also handles:
+ *   - Bootstrap: auto-load sync snapshot on init
+ *   - Periodic sync: pull delta every N seconds
+ *   - Session tracking: correlates suggest → learned within a task
+ *
+ * Usage:
+ *   const runtime = new EvolutionRuntime(client.im.evolution);
+ *   await runtime.start();
+ *
+ *   const fix = await runtime.suggest('ETIMEDOUT: connection timed out');
+ *   // ... agent applies fix.strategy ...
+ *   runtime.learned('ETIMEDOUT', 'success', 'Fixed by increasing timeout to 30s');
+ */
+
+/** Minimal interface for the evolution client — avoids circular import */
+interface EvolutionClientLike {
+    getSyncSnapshot(since?: number): Promise<{
+        data?: any;
+    }>;
+    analyze(options: Record<string, any>): Promise<{
+        data?: any;
+    }>;
+    record(options: Record<string, any>): Promise<{
+        data?: any;
+    }>;
+    sync(options: Record<string, any>): Promise<{
+        data?: any;
+    }>;
+}
+interface EvolutionRuntimeConfig {
+    /** Sync interval in ms (default: 60000 = 1 min) */
+    syncIntervalMs?: number;
+    /** Signal enrichment mode */
+    enrichment?: SignalEnrichmentConfig;
+    /** Scope for all operations (default: 'global') */
+    scope?: string;
+    /** Max outbox queue size before force flush */
+    outboxMaxSize?: number;
+    /** Outbox flush interval in ms (default: 5000) */
+    outboxFlushMs?: number;
+}
+interface Suggestion {
+    action: 'apply_gene' | 'create_suggested' | 'none';
+    geneId?: string;
+    gene?: IMGene;
+    strategy?: string[];
+    confidence: number;
+    signals: SignalTag[];
+    fromCache: boolean;
+    reason?: string;
+    alternatives?: Array<{
+        gene_id: string;
+        confidence: number;
+        title?: string;
+    }>;
+}
+/** Tracks a single suggest→learned cycle within a task. */
+interface EvolutionSession {
+    /** Unique session ID */
+    id: string;
+    /** When suggest() was called */
+    suggestedAt: number;
+    /** What gene was recommended */
+    suggestedGeneId?: string;
+    /** What gene the agent actually used (may differ from suggested) */
+    usedGeneId?: string;
+    /** Signals that triggered the suggest */
+    signals: SignalTag[];
+    /** Whether agent adopted the recommended strategy */
+    adopted: boolean;
+    /** When learned() was called (null if not yet) */
+    completedAt?: number;
+    /** Outcome */
+    outcome?: 'success' | 'failed';
+    /** Duration from suggest to learned (ms) */
+    durationMs?: number;
+    /** Confidence of the suggestion */
+    confidence: number;
+    /** Whether suggestion came from cache or server */
+    fromCache: boolean;
+}
+/** Aggregate session metrics for benchmarking. */
+interface SessionMetrics {
+    /** Total suggest() calls */
+    totalSuggestions: number;
+    /** suggest() calls that returned a gene */
+    suggestionsWithGene: number;
+    /** learned() calls */
+    totalLearned: number;
+    /** Sessions where agent used the suggested gene */
+    adoptedCount: number;
+    /** Gene Utilization Rate = adoptedCount / suggestionsWithGene */
+    geneUtilizationRate: number;
+    /** Average suggest→learned duration (ms) */
+    avgDurationMs: number;
+    /** Success rate of adopted recommendations */
+    adoptedSuccessRate: number;
+    /** Success rate without adoption (agent did it alone) */
+    nonAdoptedSuccessRate: number;
+    /** Cache hit rate */
+    cacheHitRate: number;
+}
+declare class EvolutionRuntime {
+    private client;
+    private cache;
+    private enricher;
+    private outbox;
+    private syncTimer?;
+    private flushTimer?;
+    private lastSuggestedGeneId?;
+    private started;
+    private readonly scope;
+    private readonly config;
+    private _sessions;
+    private _activeSession?;
+    private _sessionCounter;
+    constructor(client: EvolutionClientLike, config?: EvolutionRuntimeConfig);
+    /** Initialize: load snapshot + start sync + start outbox flush */
+    start(): Promise<void>;
+    /** Stop: clear timers + flush remaining outbox */
+    stop(): Promise<void>;
+    /**
+     * Get a strategy recommendation for an error/context.
+     *
+     * Flow: extract signals → try local cache (<1ms) → fallback to server (~30ms)
+     *
+     * @param error - Error message or Error object
+     * @param context - Optional additional context (provider, stage, etc.)
+     */
+    suggest(error: string | Error, context?: Partial<ExecutionContext>): Promise<Suggestion>;
+    /**
+     * Record an outcome. Fire-and-forget — never blocks, never throws.
+     *
+     * @param error - The error that was encountered
+     * @param outcome - 'success' or 'failed'
+     * @param summary - One-line summary of what happened
+     * @param geneId - Gene that was used (auto-detected from last suggest() if omitted)
+     */
+    learned(error: string | Error, outcome: 'success' | 'failed', summary: string, geneId?: string, metadata?: Record<string, any>): void;
+    /** Get all completed sessions. */
+    get sessions(): readonly EvolutionSession[];
+    /** Get aggregate metrics for benchmarking. */
+    getMetrics(): SessionMetrics;
+    /** Reset session history. */
+    resetMetrics(): void;
+    /** Sync cache with server */
+    private sync;
+    /** Flush outbox to server */
+    private flush;
+}
+
 /**
  * Prismer Cloud SDK for TypeScript/JavaScript
  *
@@ -1329,7 +2062,9 @@ declare class MessagesClient {
     /** Get message history for a conversation */
     getHistory(conversationId: string, options?: IMPaginationOptions): Promise<IMResult<IMMessage[]>>;
     /** Edit a message */
-    edit(conversationId: string, messageId: string, content: string): Promise<IMResult<void>>;
+    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>>;
 }
@@ -1379,6 +2114,292 @@ declare class WorkspaceClient {
     /** @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>>;
+}
+/** 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>>;
+}
+/** 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[]>>;
+    /** 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): 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>>;
+    /**
+     * 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;
@@ -1451,6 +2472,11 @@ declare class IMClient {
     readonly bindings: BindingsClient;
     readonly credits: CreditsClient;
     readonly workspace: WorkspaceClient;
+    readonly tasks: TasksClient;
+    readonly memory: MemoryClient;
+    readonly identity: IdentityClient;
+    readonly security: SecurityClient;
+    readonly evolution: EvolutionClient;
     readonly files: FilesClient;
     readonly realtime: IMRealtimeClient;
     /** Offline manager (null if offline mode not enabled) */
@@ -1504,4 +2530,4 @@ declare class PrismerClient {
 
 declare function createClient(config: PrismerConfig): PrismerClient;
 
-export { AccountClient, AttachmentQueue, type AuthenticatedPayload, type BatchSummary, type BatchUrlCost, BindingsClient, ContactsClient, ConversationsClient, CreditsClient, DirectClient, type DisconnectedPayload, E2EEncryption, ENVIRONMENTS, type Environment, type ErrorPayload, type FileInput, FilesClient, GroupsClient, type IMAgentCard, type IMAutocompleteResult, type IMBinding, type IMBindingData, IMClient, type IMConfirmResult, type IMContact, type IMConversation, type IMConversationsOptions, type IMCreateBindingOptions, type IMCreateGroupOptions, type IMCreditsData, type IMDiscoverAgent, type IMDiscoverOptions, type IMFileQuota, type IMGroupData, type IMGroupMember, type IMMeData, type IMMessage, type IMMessageData, type IMMultipartInitResult, type IMPaginationOptions, type IMPresignOptions, type IMPresignResult, IMRealtimeClient, type IMRegisterData, type IMRegisterOptions, type IMResult, type IMRouting, type IMSendOptions, type IMTokenData, type IMTransaction, type IMUser, type IMWorkspaceData, type IMWorkspaceInitGroupOptions, type IMWorkspaceInitOptions, IndexedDBStorage, type LoadOptions, type LoadResult, type LoadResultItem, MemoryStorage, type MessageNewPayload, MessagesClient, type OfflineConfig, type OfflineEventMap, type OfflineEventType, OfflineManager, type OutboxOperation, type ParseCost, type ParseCostBreakdown, type ParseDocument, type ParseDocumentImage, type ParseOptions, type ParseResult, type ParseUsage, type PongPayload, type PresenceChangedPayload, PrismerClient, type PrismerConfig, type QueryCost, type QuerySummary, type QueuedAttachment, type RankingFactors, type RealtimeCommand, type RealtimeConfig, type RealtimeEventMap, type RealtimeEventType, RealtimeSSEClient, type RealtimeState, RealtimeWSClient, type ReconnectingPayload, type RequestFn, SQLiteStorage, type SaveBatchOptions, type SaveOptions, type SaveResult, type SendFileOptions, type SendFileResult, type SingleUrlCost, type StorageAdapter, type StoredContact, type StoredConversation, type StoredMessage, type SyncEvent, type SyncResult, TabCoordinator, type TypingIndicatorPayload, type UploadOptions, type UploadResult, WorkspaceClient, createClient, PrismerClient as default };
+export { AccountClient, AttachmentQueue, type AuthenticatedPayload, type BatchSummary, type BatchUrlCost, BindingsClient, ContactsClient, ConversationsClient, CreditsClient, type DecryptResult, type DerivationMode, DirectClient, type DisconnectedPayload, E2EEncryption, ENVIRONMENTS, type EncryptedContextResult, type EncryptedFileResult, type EncryptedMessage, type Environment, type ErrorPayload, EvolutionCache, EvolutionClient, EvolutionRuntime, type EvolutionRuntimeConfig, type EvolutionSession, type EvolutionSyncDelta, type EvolutionSyncSnapshot, type ExecutionContext, type FileInput, FilesClient, type GeneCategory, type GeneSelectionResult, type GeneVisibility, GroupsClient, type IMAgentCard, type IMAgentPersonality, type IMAgentSkillRecord, type IMAnalyzeOptions, type IMAnalyzeResult, type IMAutocompleteResult, type IMBinding, type IMBindingData, type IMCapsule, IMClient, type IMCompactOptions, type IMCompactionSummary, type IMCompleteTaskOptions, type IMConfirmResult, type IMContact, type IMConversation, type IMConversationsOptions, type IMCreateBindingOptions, type IMCreateGeneOptions, type IMCreateGroupOptions, type IMCreateMemoryFileOptions, type IMCreateTaskOptions, type IMCreditsData, type IMDiscoverAgent, type IMDiscoverOptions, type IMEvolutionEdge, type IMEvolutionStats, type IMFileQuota, type IMForkGeneOptions, type IMGene, type IMGeneListOptions, type IMGroupData, type IMGroupMember, type IMIdentityKey, type IMKeyAuditEntry, type IMKeyVerifyResult, type IMMeData, type IMMemoryFile, type IMMemoryFileDetail, type IMMemoryLoadResult, type IMMessage, type IMMessageData, type IMMultipartInitResult, type IMPaginationOptions, type IMPresignOptions, type IMPresignResult, IMRealtimeClient, type IMRecordOutcomeOptions, type IMRegisterData, type IMRegisterKeyOptions, type IMRegisterOptions, type IMResult, type IMRouting, type IMSendOptions, type IMSkillContent, type IMSkillInfo, type IMSkillInstallResult, type IMTask, type IMTaskDetail, type IMTaskListOptions, type IMTaskLog, type IMTokenData, type IMTransaction, type IMUpdateMemoryFileOptions, type IMUpdateTaskOptions, type IMUser, type IMWorkspaceData, type IMWorkspaceInitGroupOptions, type IMWorkspaceInitOptions, IdentityClient, IndexedDBStorage, type LoadOptions, type LoadResult, type LoadResultItem, MemoryClient, MemoryStorage, type MessageDeletedPayload, type MessageEditPayload, type MessageNewPayload, MessagesClient, type OfflineConfig, type OfflineEventMap, type OfflineEventType, OfflineManager, type OutboxOperation, type ParseCost, type ParseCostBreakdown, type ParseDocument, type ParseDocumentImage, type ParseOptions, type ParseResult, type ParseUsage, type PongPayload, type PresenceChangedPayload, PrismerClient, type PrismerConfig, type QueryCost, type QuerySummary, type QueuedAttachment, type RankingFactors, type RealtimeCommand, type RealtimeConfig, type RealtimeEventMap, type RealtimeEventType, RealtimeSSEClient, type RealtimeState, RealtimeWSClient, type ReconnectingPayload, type RequestFn, SQLiteStorage, type SaveBatchOptions, type SaveOptions, type SaveResult, type ScheduleType, SecurityClient, type SendFileOptions, type SendFileResult, type SessionMetrics, type SignalEnrichmentConfig, type SignalTag, type SingleUrlCost, type StorageAdapter, type StoredContact, type StoredConversation, type StoredMessage, type Suggestion, type SyncEvent, type SyncResult, TabCoordinator, type TaskStatus, TasksClient, type TypingIndicatorPayload, type UploadOptions, type UploadResult, WorkspaceClient, createClient, createEnrichedExtractor, decryptContext, decryptFile, decryptMessages, decryptOnReceive, PrismerClient as default, encryptContext, encryptFile, encryptForSend, extractSignals };