agentix-cli 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -598,6 +598,7 @@ declare class ToolExecutor {
     private runCommand;
     private editFile;
     private createFiles;
+    private spawnAgent;
     private askUser;
 }
 
@@ -809,15 +810,22 @@ declare class UsageTracker {
 }
 declare const globalTracker: UsageTracker;
 
-declare function setDebug(enabled: boolean): void;
-declare function isDebug(): boolean;
+type DebugCategory = "webhook" | "agent" | "channel" | "cron" | "mesh" | "context" | "memory" | "config" | "all";
+declare function setDebug(enabled: boolean, categories?: DebugCategory[]): void;
+declare function isDebug(category?: DebugCategory): boolean;
 declare const debug: {
     log(...args: unknown[]): void;
+    /** Log with a specific category — only outputs if that category is enabled */
+    cat(category: DebugCategory, message: string, ...extra: unknown[]): void;
     step(step: number, message: string): void;
     hook(name: string, duration: number, result: string): void;
     api(method: string, model: string, tokens?: number): void;
     tokens(input: number, output: number, cost: number): void;
     context(label: string, detail: string): void;
+    /** Log webhook event with full payload summary */
+    webhook(channel: string, event: string, detail: string): void;
+    /** Log channel lifecycle event */
+    channel(name: string, event: string, detail?: string): void;
 };
 
 interface Session {
@@ -1277,6 +1285,23 @@ declare const agentConfigSchema: z.ZodObject<{
     mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     maxConcurrent: z.ZodDefault<z.ZodNumber>;
     permissionMode: z.ZodDefault<z.ZodString>;
+    queueMode: z.ZodDefault<z.ZodEnum<["collect", "followup", "drop"]>>;
+    heartbeat: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        intervalMinutes: z.ZodDefault<z.ZodNumber>;
+        prompt: z.ZodDefault<z.ZodString>;
+        channel: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        prompt: string;
+        channel: string;
+        intervalMinutes: number;
+    }, {
+        enabled?: boolean | undefined;
+        prompt?: string | undefined;
+        channel?: string | undefined;
+        intervalMinutes?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     workspace: string;
@@ -1284,6 +1309,13 @@ declare const agentConfigSchema: z.ZodObject<{
     mentions: string[];
     maxConcurrent: number;
     permissionMode: string;
+    queueMode: "collect" | "followup" | "drop";
+    heartbeat: {
+        enabled: boolean;
+        prompt: string;
+        channel: string;
+        intervalMinutes: number;
+    };
     provider?: string | undefined;
     model?: string | undefined;
     systemPrompt?: string | undefined;
@@ -1292,11 +1324,18 @@ declare const agentConfigSchema: z.ZodObject<{
     workspace: string;
     provider?: string | undefined;
     model?: string | undefined;
-    systemPrompt?: string | undefined;
     tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+    systemPrompt?: string | undefined;
     mentions?: string[] | undefined;
     maxConcurrent?: number | undefined;
     permissionMode?: string | undefined;
+    queueMode?: "collect" | "followup" | "drop" | undefined;
+    heartbeat?: {
+        enabled?: boolean | undefined;
+        prompt?: string | undefined;
+        channel?: string | undefined;
+        intervalMinutes?: number | undefined;
+    } | undefined;
 }>;
 declare const cronJobSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1307,15 +1346,33 @@ declare const cronJobSchema: z.ZodObject<{
     timeout: z.ZodDefault<z.ZodNumber>;
     model: z.ZodOptional<z.ZodString>;
     onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+    notify: z.ZodOptional<z.ZodObject<{
+        channel: z.ZodString;
+        chatId: z.ZodString;
+        accountId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    }, {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     agent: string;
-    timeout: number;
     prompt: string;
+    timeout: number;
     schedule: string;
     timezone: string;
     onError: "log" | "notify" | "disable";
     model?: string | undefined;
+    notify?: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    } | undefined;
 }, {
     agent: string;
     prompt: string;
@@ -1324,6 +1381,11 @@ declare const cronJobSchema: z.ZodObject<{
     enabled?: boolean | undefined;
     timeout?: number | undefined;
     timezone?: string | undefined;
+    notify?: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    } | undefined;
     onError?: "log" | "notify" | "disable" | undefined;
 }>;
 declare const meshPeerSchema: z.ZodObject<{
@@ -1376,6 +1438,23 @@ declare const daemonConfigSchema: z.ZodObject<{
         mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         maxConcurrent: z.ZodDefault<z.ZodNumber>;
         permissionMode: z.ZodDefault<z.ZodString>;
+        queueMode: z.ZodDefault<z.ZodEnum<["collect", "followup", "drop"]>>;
+        heartbeat: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            intervalMinutes: z.ZodDefault<z.ZodNumber>;
+            prompt: z.ZodDefault<z.ZodString>;
+            channel: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            prompt: string;
+            channel: string;
+            intervalMinutes: number;
+        }, {
+            enabled?: boolean | undefined;
+            prompt?: string | undefined;
+            channel?: string | undefined;
+            intervalMinutes?: number | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         workspace: string;
@@ -1383,6 +1462,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         mentions: string[];
         maxConcurrent: number;
         permissionMode: string;
+        queueMode: "collect" | "followup" | "drop";
+        heartbeat: {
+            enabled: boolean;
+            prompt: string;
+            channel: string;
+            intervalMinutes: number;
+        };
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
@@ -1391,11 +1477,18 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         provider?: string | undefined;
         model?: string | undefined;
-        systemPrompt?: string | undefined;
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         maxConcurrent?: number | undefined;
         permissionMode?: string | undefined;
+        queueMode?: "collect" | "followup" | "drop" | undefined;
+        heartbeat?: {
+            enabled?: boolean | undefined;
+            prompt?: string | undefined;
+            channel?: string | undefined;
+            intervalMinutes?: number | undefined;
+        } | undefined;
     }>>>;
     channels: z.ZodDefault<z.ZodObject<{
         telegram: z.ZodDefault<z.ZodObject<{
@@ -1513,42 +1606,47 @@ declare const daemonConfigSchema: z.ZodObject<{
                 agentId: z.ZodString;
                 gitlabUsernames: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                 keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+                token: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
                 agentId: string;
                 gitlabUsernames: string[];
                 keywords: string[];
+                token?: string | undefined;
             }, {
                 agentId: string;
+                token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
             }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
-            host: string;
             routes: {
                 agent: string;
                 project: string;
             }[];
             webhookPort: number;
+            host: string;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
                 keywords: string[];
+                token?: string | undefined;
             }[];
             token?: string | undefined;
             webhookSecret?: string | undefined;
         }, {
             enabled?: boolean | undefined;
             token?: string | undefined;
-            host?: string | undefined;
             routes?: {
                 agent: string;
                 project: string;
             }[] | undefined;
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
+            host?: string | undefined;
             agentMappings?: {
                 agentId: string;
+                token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
             }[] | undefined;
@@ -1583,16 +1681,17 @@ declare const daemonConfigSchema: z.ZodObject<{
         };
         gitlab: {
             enabled: boolean;
-            host: string;
             routes: {
                 agent: string;
                 project: string;
             }[];
             webhookPort: number;
+            host: string;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
                 keywords: string[];
+                token?: string | undefined;
             }[];
             token?: string | undefined;
             webhookSecret?: string | undefined;
@@ -1628,15 +1727,16 @@ declare const daemonConfigSchema: z.ZodObject<{
         gitlab?: {
             enabled?: boolean | undefined;
             token?: string | undefined;
-            host?: string | undefined;
             routes?: {
                 agent: string;
                 project: string;
             }[] | undefined;
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
+            host?: string | undefined;
             agentMappings?: {
                 agentId: string;
+                token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
             }[] | undefined;
@@ -1651,15 +1751,33 @@ declare const daemonConfigSchema: z.ZodObject<{
         timeout: z.ZodDefault<z.ZodNumber>;
         model: z.ZodOptional<z.ZodString>;
         onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+        notify: z.ZodOptional<z.ZodObject<{
+            channel: z.ZodString;
+            chatId: z.ZodString;
+            accountId: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        }, {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         agent: string;
-        timeout: number;
         prompt: string;
+        timeout: number;
         schedule: string;
         timezone: string;
         onError: "log" | "notify" | "disable";
         model?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
     }, {
         agent: string;
         prompt: string;
@@ -1668,6 +1786,11 @@ declare const daemonConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         timeout?: number | undefined;
         timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
         onError?: "log" | "notify" | "disable" | undefined;
     }>>>;
     mesh: z.ZodDefault<z.ZodObject<{
@@ -1729,10 +1852,30 @@ declare const daemonConfigSchema: z.ZodObject<{
         mentions: string[];
         maxConcurrent: number;
         permissionMode: string;
+        queueMode: "collect" | "followup" | "drop";
+        heartbeat: {
+            enabled: boolean;
+            prompt: string;
+            channel: string;
+            intervalMinutes: number;
+        };
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
     }>;
+    mesh: {
+        enabled: boolean;
+        peers: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[];
+        discovery: "static" | "mdns";
+        healthCheck: {
+            timeout: number;
+            interval: number;
+        };
+    };
     node: {
         id: string;
         name: string;
@@ -1773,16 +1916,17 @@ declare const daemonConfigSchema: z.ZodObject<{
         };
         gitlab: {
             enabled: boolean;
-            host: string;
             routes: {
                 agent: string;
                 project: string;
             }[];
             webhookPort: number;
+            host: string;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
                 keywords: string[];
+                token?: string | undefined;
             }[];
             token?: string | undefined;
             webhookSecret?: string | undefined;
@@ -1791,26 +1935,18 @@ declare const daemonConfigSchema: z.ZodObject<{
     crons: Record<string, {
         enabled: boolean;
         agent: string;
-        timeout: number;
         prompt: string;
+        timeout: number;
         schedule: string;
         timezone: string;
         onError: "log" | "notify" | "disable";
         model?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
     }>;
-    mesh: {
-        enabled: boolean;
-        peers: {
-            name: string;
-            url: string;
-            token?: string | undefined;
-        }[];
-        discovery: "static" | "mdns";
-        healthCheck: {
-            timeout: number;
-            interval: number;
-        };
-    };
 }, {
     node: {
         id: string;
@@ -1822,12 +1958,32 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         provider?: string | undefined;
         model?: string | undefined;
-        systemPrompt?: string | undefined;
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         maxConcurrent?: number | undefined;
         permissionMode?: string | undefined;
+        queueMode?: "collect" | "followup" | "drop" | undefined;
+        heartbeat?: {
+            enabled?: boolean | undefined;
+            prompt?: string | undefined;
+            channel?: string | undefined;
+            intervalMinutes?: number | undefined;
+        } | undefined;
     }> | undefined;
+    mesh?: {
+        enabled?: boolean | undefined;
+        peers?: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[] | undefined;
+        discovery?: "static" | "mdns" | undefined;
+        healthCheck?: {
+            timeout?: number | undefined;
+            interval?: number | undefined;
+        } | undefined;
+    } | undefined;
     providers?: Record<string, {
         apiKey?: string | undefined;
         defaultModel?: string | undefined;
@@ -1864,15 +2020,16 @@ declare const daemonConfigSchema: z.ZodObject<{
         gitlab?: {
             enabled?: boolean | undefined;
             token?: string | undefined;
-            host?: string | undefined;
             routes?: {
                 agent: string;
                 project: string;
             }[] | undefined;
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
+            host?: string | undefined;
             agentMappings?: {
                 agentId: string;
+                token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
             }[] | undefined;
@@ -1886,21 +2043,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         enabled?: boolean | undefined;
         timeout?: number | undefined;
         timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
         onError?: "log" | "notify" | "disable" | undefined;
     }> | undefined;
-    mesh?: {
-        enabled?: boolean | undefined;
-        peers?: {
-            name: string;
-            url: string;
-            token?: string | undefined;
-        }[] | undefined;
-        discovery?: "static" | "mdns" | undefined;
-        healthCheck?: {
-            timeout?: number | undefined;
-            interval?: number | undefined;
-        } | undefined;
-    } | undefined;
 }>;
 type DaemonConfig = z.infer<typeof daemonConfigSchema>;
 type AgentDef = z.infer<typeof agentConfigSchema>;
@@ -1968,14 +2117,29 @@ declare class AgentXDaemon {
     private cron;
     private mesh?;
     private hooks;
+    private landscape;
+    private heartbeat;
     private httpServer?;
     private webhooks;
     private log;
+    private sseClients;
     constructor(configPath?: string);
     start(): Promise<void>;
     stop(): Promise<void>;
+    private midnightTimer?;
+    private scheduleMidnightHook;
+    private runDailyCostReport;
     private startChannels;
     private startHttpApi;
+    /**
+     * Broadcast an SSE event to all connected clients.
+     */
+    private broadcastSSE;
+    /**
+     * Handle SSE connection for live event streaming.
+     * GET /events — streams daemon logs in real-time.
+     */
+    private handleSSE;
     private handleHttp;
     /**
      * OpenAI-compatible chat completions endpoint.
@@ -2004,6 +2168,79 @@ interface AgentUsage {
     cacheCreateTokens: number;
     totalDuration: number;
     errors: number;
+    model?: string;
+}
+interface DailyReport {
+    date: string;
+    totalTasks: number;
+    totalInput: number;
+    totalOutput: number;
+    totalCacheRead: number;
+    totalCacheCreate: number;
+    totalCost: number;
+    topAgent: string;
+    topCost: number;
+    agentCosts: Record<string, number>;
+}
+declare class TokenTracker {
+    private dir;
+    private cache;
+    constructor(baseDir?: string);
+    /**
+     * Calculate cost for an agent's usage with cache-aware pricing.
+     */
+    static calculateCost(usage: AgentUsage): number;
+    /**
+     * Record a task execution with real or estimated token counts.
+     */
+    record(agentId: string, duration: number, realUsage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheCreateTokens: number;
+    }, messageLength?: number, responseLength?: number, error?: boolean, model?: string): void;
+    /**
+     * Get today's usage summary.
+     */
+    today(): DailyUsage;
+    /**
+     * Get usage for a specific date.
+     */
+    getDate(date: string): DailyUsage | null;
+    /**
+     * Generate a daily cost report for a given date.
+     */
+    generateDailyReport(date?: string): DailyReport | null;
+    /**
+     * Append a daily report row to TOKEN_COSTS.md.
+     */
+    appendToTokenCosts(report: DailyReport, filePath?: string): void;
+    /**
+     * Get summary across last N days.
+     */
+    summary(days?: number): {
+        totalTasks: number;
+        totalTokens: number;
+        totalInput: number;
+        totalOutput: number;
+        totalCacheRead: number;
+        totalCacheCreate: number;
+        cacheHitRatio: number;
+        totalErrors: number;
+        totalCost: number;
+        byAgent: Record<string, {
+            tasks: number;
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheCreate: number;
+            total: number;
+            avgDuration: number;
+            cost: number;
+        }>;
+    };
+    private filePath;
+    private save;
 }
 
 interface AgentPeer {
@@ -2018,7 +2255,13 @@ interface AgentTask {
     context?: {
         channel?: string;
         sender?: string;
+        /** Platform user ID (e.g. Telegram user ID) */
+        senderId?: string;
+        /** Platform username (e.g. @username) */
+        senderUsername?: string;
         group?: string;
+        /** Stable chat ID for session keying (e.g. "project:issue:123" for GitLab) */
+        chatId?: string;
         /** Attached media file (image, audio, video, document) */
         mediaPath?: string;
         mediaType?: string;
@@ -2032,6 +2275,21 @@ interface AgentTask {
         myHandle?: string;
         /** Other available agents and their handles */
         peers?: AgentPeer[];
+        /** Verified channel metadata (from adapter) */
+        channelMeta?: {
+            agents?: Array<{
+                id: string;
+                name: string;
+                handle?: string;
+            }>;
+            project?: string;
+            issue?: {
+                type: string;
+                iid: string;
+                title: string;
+            };
+            facts?: string[];
+        };
     };
 }
 interface AgentResponse {
@@ -2074,62 +2332,335 @@ declare function executeTask(agent: AgentDef, task: AgentTask, providers: Record
     apiKey?: string;
 }>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string): Promise<AgentResponse>;
 
-declare class AgentRegistry {
-    private agents;
-    private config;
-    private providers;
-    private sessions;
-    private wikis;
-    private rateLimiter;
-    private tokenTracker;
+type WikiAccess = "private" | "shared" | "public";
+/**
+ * Article metadata. Intentionally minimal — tags do the heavy lifting.
+ */
+interface WikiArticleMeta {
+    title: string;
+    tags: string[];
+    owner: string;
+    access: WikiAccess;
+    sharedWith?: string[];
+    created: string;
+    lastUpdated: string;
+    sources: string[];
+}
+interface WikiArticle {
+    meta: WikiArticleMeta;
+    content: string;
+    path: string;
+}
+interface WikiEntry {
+    id: string;
+    date: string;
+    agentId: string;
+    source: string;
+    sourceContext?: string;
+    content: string;
+    meta?: Record<string, unknown>;
+}
+interface WikiIndex {
+    articles: Array<{
+        path: string;
+        title: string;
+        tags: string[];
+        owner: string;
+        access: WikiAccess;
+        sharedWith?: string[];
+        aliases: string[];
+        backlinks: number;
+        sources?: string[];
+        lastUpdated?: string;
+    }>;
+    lastRebuilt: string;
+}
+
+declare class WikiStore {
+    private baseDir;
+    private rawDir;
     private log;
-    constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
+    constructor(baseDir?: string, log?: (...args: unknown[]) => void);
     /**
-     * Get agent definition by ID.
+     * Check if an agent can read an article.
      */
-    getAgent(id: string): AgentDef | undefined;
+    canRead(article: WikiArticleMeta, agentId?: string): boolean;
     /**
-     * Find agent by mention pattern (e.g., "@nadia" -> "marketing-agent").
-     * Returns the agent with the longest (most specific) mention match.
+     * Check if an agent can write an article.
      */
-    findByMention(text: string): string | undefined;
+    canWrite(article: WikiArticleMeta, agentId: string): boolean;
     /**
-     * Find ALL agents mentioned in text (for bot-to-bot detection).
+     * Add a raw entry (from a conversation, cron result, etc.)
      */
-    findAllMentioned(text: string): string[];
+    addEntry(entry: WikiEntry): string;
     /**
-     * Get or create per-agent wiki (Karpathy design: each agent has its own knowledge base).
+     * List raw entries, optionally filtered by agent or date range.
      */
-    private getWiki;
+    listEntries(filter?: {
+        agentId?: string;
+        after?: string;
+        before?: string;
+    }): WikiEntry[];
+    private parseEntry;
     /**
-     * Build peer list for context engine.
+     * Write or update a wiki article.
      */
-    private buildPeerList;
+    writeArticle(path: string, meta: WikiArticleMeta, content: string, agentId: string): boolean;
     /**
-     * Get the primary channel handle for an agent (e.g. "@noqta_devops_bot" on telegram).
+     * Read an article. Returns null if not found.
      */
-    private getChannelHandle;
+    readArticle(path: string): WikiArticle | null;
     /**
-     * Execute a task on an agent. Respects maxConcurrent limit.
+     * Read an article with permission check.
      */
-    execute(task: AgentTask, onDelta?: StreamCallback): Promise<AgentResponse>;
+    readArticleAs(path: string, agentId: string): WikiArticle | null;
+    private parseArticle;
     /**
-     * List all agents and their status.
+     * List all articles accessible to an agent.
      */
-    list(): Array<{
-        id: string;
-        name: string;
-        tier: string;
-        workspace: string;
-        active: number;
-        total: number;
-        errors: number;
-        lastActive?: Date;
-    }>;
+    listArticles(agentId: string): WikiArticle[];
     /**
-     * Get token usage summary.
+     * Search articles by keyword. Returns articles the agent can read.
      */
-    getUsage(days?: number): {
+    search(query: string, agentId: string, maxResults?: number): WikiArticle[];
+    /**
+     * Find articles relevant to a message (for context injection).
+     * Extracts keywords from the message and searches the wiki.
+     */
+    findRelevant(message: string, agentId?: string, maxArticles?: number): WikiArticle[];
+    /**
+     * Build context string from relevant wiki articles for prompt injection.
+     * Token-efficient: includes title + first ~500 chars of each article.
+     */
+    buildContext(articles: WikiArticle[], maxChars?: number): string;
+    /**
+     * Rebuild the master index.
+     */
+    rebuildIndex(): WikiIndex;
+    /**
+     * Get wiki stats.
+     */
+    stats(): {
+        totalArticles: number;
+        totalEntries: number;
+        articlesByType: Record<string, number>;
+        articlesByAccess: Record<string, number>;
+        articlesByOwner: Record<string, number>;
+    };
+    /**
+     * Append an entry to log.md.
+     * Format: ## [YYYY-MM-DD HH:MM] action | details
+     */
+    appendLog(action: string, details: string): void;
+    /**
+     * Get recent log entries.
+     */
+    getLog(limit?: number): string[];
+    /**
+     * Create _schema.md if it doesn't exist.
+     * This tells the LLM how to operate on the wiki.
+     */
+    private ensureSchema;
+    /**
+     * Extract all [[wikilinks]] from article content.
+     */
+    extractWikilinks(content: string): string[];
+    /**
+     * Build backlinks index: for each article, which other articles link to it.
+     */
+    buildBacklinks(): Record<string, string[]>;
+    /**
+     * Get backlinks for a specific article title.
+     */
+    getBacklinks(title: string): string[];
+    /**
+     * Find articles matching ANY of the given tags.
+     * This is how agents get relevant context — only articles tagged with
+     * the client/project/topic they're working on.
+     */
+    findByTags(tags: string[], agentId?: string, limit?: number): WikiArticle[];
+    /**
+     * Get all unique tags across all articles.
+     */
+    getAllTags(): Map<string, number>;
+    /**
+     * Get the worldview file. This is the user's description of their world —
+     * the LLM uses it during absorb to know where things go.
+     * Returns null if not set.
+     */
+    getWorldview(): string | null;
+    /**
+     * Set the worldview. The user describes their world: companies, clients,
+     * projects, team, processes. The LLM uses this as context during absorb.
+     */
+    setWorldview(content: string): void;
+    /**
+     * Run a lint pass on the wiki. Returns issues found.
+     */
+    lint(): Array<{
+        type: string;
+        article: string;
+        message: string;
+    }>;
+    /**
+     * Get unabsorbed entries (entries not referenced by any article's sources field).
+     */
+    getUnabsorbedEntries(): WikiEntry[];
+    /**
+     * Build an absorb prompt for unprocessed entries.
+     * Returns a prompt string an agent can execute to compile entries into articles.
+     */
+    buildAbsorbPrompt(maxEntries?: number): string | null;
+    private walkDir;
+}
+
+type WikiMode = "flat" | "graph" | "unified";
+/**
+ * WikiHub: manages per-agent wikis with a shared raw entry pool.
+ * Supports two compilation modes:
+ *   - flat:  Karpathy pattern — tags, LLM-chosen paths, worldview, gap detection
+ *   - graph: Knowledge graph — kind, parent, hierarchy, events, entities
+ *
+ * Both modes share the same raw entries. Articles stored separately:
+ *   agents/<id>/flat/    ← Karpathy compilation
+ *   agents/<id>/graph/   ← Knowledge graph compilation
+ */
+declare class WikiHub {
+    private baseDir;
+    private agentsDir;
+    private mode;
+    private sharedStore;
+    private agentStores;
+    private log;
+    constructor(baseDir?: string, log?: (...args: unknown[]) => void, mode?: WikiMode);
+    getMode(): WikiMode;
+    /**
+     * Get or create the wiki store for a specific agent (mode-aware).
+     * flat:  agents/<id>/flat/
+     * graph: agents/<id>/graph/
+     */
+    getAgentWiki(agentId: string): WikiStore;
+    getSharedStore(): WikiStore;
+    listAgents(): string[];
+    getAgentEntries(agentId: string): WikiEntry[];
+    getUnabsorbedEntries(agentId: string): WikiEntry[];
+    summary(): AgentWikiSummary[];
+}
+interface AgentWikiSummary {
+    agentId: string;
+    totalEntries: number;
+    totalArticles: number;
+    unabsorbed: number;
+    articles: Array<{
+        title: string;
+        path: string;
+        tags?: string[];
+    }>;
+}
+
+interface MeshPeerInfo {
+    peer: string;
+    healthy: boolean;
+    skills: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+}
+/**
+ * Build and cache per-agent landscape strings.
+ */
+declare class LandscapeBuilder {
+    private cache;
+    private config;
+    private meshPeers;
+    constructor(config: DaemonConfig);
+    /**
+     * Build landscape strings for all agents. Call at startup.
+     */
+    build(meshPeers?: MeshPeerInfo[]): void;
+    /**
+     * Get the cached landscape string for a specific agent.
+     */
+    getForAgent(agentId: string): string | undefined;
+    /**
+     * Rebuild after mesh topology changes.
+     */
+    refresh(meshPeers: MeshPeerInfo[]): void;
+    private renderForAgent;
+    private renderChannels;
+    /**
+     * Get the primary Telegram handle for an agent (the @username).
+     */
+    private getPrimaryHandle;
+    /**
+     * Extract a short capability description from systemPrompt.
+     * Takes the first sentence, max 80 chars.
+     */
+    private extractCapability;
+}
+
+declare class AgentRegistry {
+    private agents;
+    private config;
+    private providers;
+    private sessions;
+    private wikiHub;
+    private memoryStore;
+    private rateLimiter;
+    private tokenTracker;
+    private landscape?;
+    private messageQueue;
+    private log;
+    constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
+    /**
+     * Set landscape builder (called after mesh init).
+     */
+    setLandscape(builder: LandscapeBuilder): void;
+    /**
+     * Get agent definition by ID.
+     */
+    getAgent(id: string): AgentDef | undefined;
+    /**
+     * Find agent by mention pattern (e.g., "@my_bot" -> "my-agent").
+     * Returns the agent with the longest (most specific) mention match.
+     */
+    findByMention(text: string): string | undefined;
+    /**
+     * Find ALL agents mentioned in text (for bot-to-bot detection).
+     */
+    findAllMentioned(text: string): string[];
+    /** Wiki hub accessor. */
+    getWikiHub(): WikiHub;
+    /**
+     * Build peer list for context engine.
+     */
+    private buildPeerList;
+    /**
+     * Get the primary channel handle for an agent (e.g. "@my_bot" on telegram).
+     */
+    private getChannelHandle;
+    /**
+     * Execute a task on an agent. Respects maxConcurrent limit.
+     */
+    execute(task: AgentTask, onDelta?: StreamCallback): Promise<AgentResponse>;
+    /**
+     * List all agents and their status.
+     */
+    list(): Array<{
+        id: string;
+        name: string;
+        tier: string;
+        workspace: string;
+        active: number;
+        total: number;
+        errors: number;
+        lastActive?: Date;
+    }>;
+    /**
+     * Get token usage summary.
+     */
+    getUsage(days?: number): {
         totalTasks: number;
         totalTokens: number;
         totalInput: number;
@@ -2138,6 +2669,7 @@ declare class AgentRegistry {
         totalCacheCreate: number;
         cacheHitRatio: number;
         totalErrors: number;
+        totalCost: number;
         byAgent: Record<string, {
             tasks: number;
             input: number;
@@ -2146,14 +2678,43 @@ declare class AgentRegistry {
             cacheCreate: number;
             total: number;
             avgDuration: number;
+            cost: number;
         }>;
     };
     /**
      * Get today's usage.
      */
     getTodayUsage(): DailyUsage;
+    /**
+     * Get the token tracker instance (for daemon hooks).
+     */
+    getTokenTracker(): TokenTracker;
 }
 
+/**
+ * Verified channel context — facts the channel adapter knows for certain.
+ * Prevents agents from hallucinating about their environment.
+ */
+interface ChannelMeta {
+    /** Channel name */
+    channel: string;
+    /** Verified agents/bots present in this chat/group/project */
+    agents?: Array<{
+        id: string;
+        name: string;
+        handle?: string;
+    }>;
+    /** Project path (GitLab) or group topic */
+    project?: string;
+    /** Issue/MR context (GitLab) */
+    issue?: {
+        type: string;
+        iid: string;
+        title: string;
+    };
+    /** Channel-specific facts (e.g., pipeline status, group description) */
+    facts?: string[];
+}
 interface IncomingMessage {
     id: string;
     channel: string;
@@ -2178,6 +2739,7 @@ interface IncomingMessage {
     };
     raw?: unknown;
     resolvedAgent?: string;
+    channelMeta?: ChannelMeta;
 }
 interface OutgoingMessage {
     channel: string;
@@ -2185,6 +2747,7 @@ interface OutgoingMessage {
     text: string;
     replyTo?: string;
     parseMode?: "markdown" | "html" | "plain";
+    agentId?: string;
 }
 interface ChannelAdapter {
     readonly name: string;
@@ -2202,6 +2765,8 @@ interface ChannelAdapter {
     react?(chatId: string, messageId: string, emoji?: string): Promise<void>;
     /** Register handler for incoming messages */
     onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
+    /** Get verified context for a chat (optional — channels implement what they can) */
+    getChannelMeta?(chatId: string): Promise<ChannelMeta | undefined>;
 }
 
 declare class MessageRouter {
@@ -2215,6 +2780,17 @@ declare class MessageRouter {
     constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
     setMesh(mesh: A2AMesh): void;
     addChannel(adapter: ChannelAdapter): void;
+    /**
+     * Send an outbound message to any registered channel.
+     * Used for agent-initiated messages, cron notifications, cross-channel routing.
+     *
+     * If accountId is not provided for Telegram, auto-resolves from agentId binding.
+     */
+    sendOutbound(msg: OutgoingMessage & {
+        accountId?: string;
+    }): Promise<string | void>;
+    /** List registered channel names. */
+    getChannelNames(): string[];
     startAll(): Promise<void>;
     stopAll(): Promise<void>;
     private handleMessage;
@@ -2224,7 +2800,7 @@ declare class MessageRouter {
      * Guards:
      * 1. Max depth (default 3)
      * 2. No agent called twice in the same chain (prevents A→B→A→B loops)
-     * 3. Only on channels that support it (Telegram)
+     * Works on Telegram (multi-account), WhatsApp (shared number), Discord.
      */
     private handleBotToBotChain;
     private adapterSend;
@@ -2269,6 +2845,8 @@ declare class TelegramAdapter implements ChannelAdapter {
     private resolveToken;
     /** Track which account a chat was last seen on (for DMs) */
     private chatAccountMap;
+    private botInfo;
+    private groupStore;
     /**
      * Send a message. Returns the sent message ID.
      * Pass accountId to send from a specific bot account.
@@ -2289,6 +2867,16 @@ declare class TelegramAdapter implements ChannelAdapter {
      */
     sendTyping(chatId: string, accountId?: string): Promise<void>;
     private pollLoop;
+    /**
+     * Get verified context for a Telegram chat.
+     * Reads from persistent group store (fed by my_chat_member events + API seed).
+     */
+    getChannelMeta(chatId: string): Promise<ChannelMeta | undefined>;
+    /**
+     * Seed group membership by querying the Telegram API for each bot.
+     * Called once per group on first encounter, then maintained via my_chat_member events.
+     */
+    private seedGroupMembership;
     private apiCall;
 }
 
@@ -2305,6 +2893,9 @@ declare class WhatsAppAdapter implements ChannelAdapter {
     private routes;
     private handler?;
     private sock;
+    private reconnectAttempts;
+    /** Generation counter — incremented on each start() to ignore stale socket events */
+    private generation;
     private sentMessageIds;
     private log;
     constructor(config: {
@@ -2338,8 +2929,13 @@ interface CronJobState {
     onError: "log" | "notify" | "disable";
     lastRun?: Date;
     nextRun?: Date;
+    lastSuccess?: Date;
+    lastError?: string;
     consecutiveErrors: number;
     totalRuns: number;
+    totalFailures: number;
+    /** Whether a retry is currently pending */
+    retryPending?: boolean;
 }
 interface CronRunResult {
     jobId: string;
@@ -2349,190 +2945,67 @@ interface CronRunResult {
     response?: string;
     error?: string;
     duration: number;
+    /** Was this a retry attempt? */
+    isRetry?: boolean;
+    retryAttempt?: number;
 }
 
+/** Notification callback — injected by daemon to send alerts via channels */
+type CronNotifyCallback = (jobId: string, agent: string, error: string, consecutiveErrors: number) => Promise<void>;
 declare class CronScheduler {
     private jobs;
     private timers;
     private registry;
     private hooks?;
     private runsDir;
+    private lastRunFile;
     private running;
+    private notifyCallback?;
     private log;
     constructor(config: DaemonConfig, registry: AgentRegistry, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
+    /**
+     * Set a notification callback for failed crons.
+     * Called when onError is "notify" or after multiple consecutive failures.
+     */
+    setNotifyCallback(cb: CronNotifyCallback): void;
     start(): Promise<void>;
     stop(): Promise<void>;
     private scheduleNext;
+    private scheduleRetry;
     private executeJob;
-    private logRun;
-    /**
-     * List all jobs and their status.
-     */
-    list(): CronJobState[];
-}
-
-/**
- * Access levels for wiki articles:
- * - private: only the owning agent can read/write
- * - shared: specific agents listed in `sharedWith` can read, owner can write
- * - public: all agents on this node can read, owner can write
- */
-type WikiAccess = "private" | "shared" | "public";
-interface WikiArticleMeta {
-    title: string;
-    type: string;
-    owner: string;
-    access: WikiAccess;
-    sharedWith?: string[];
-    created: string;
-    lastUpdated: string;
-    related: string[];
-    sources: string[];
-    tags?: string[];
-}
-interface WikiArticle {
-    meta: WikiArticleMeta;
-    content: string;
-    path: string;
-}
-interface WikiEntry {
-    id: string;
-    date: string;
-    agentId: string;
-    source: string;
-    sourceContext?: string;
-    content: string;
-    meta?: Record<string, unknown>;
-}
-interface WikiIndex {
-    articles: Array<{
-        path: string;
-        title: string;
-        type: string;
-        owner: string;
-        access: WikiAccess;
-        sharedWith?: string[];
-        aliases: string[];
-        backlinks: number;
-    }>;
-    lastRebuilt: string;
-}
-
-declare class WikiStore {
-    private baseDir;
-    private rawDir;
-    private log;
-    constructor(baseDir?: string, log?: (...args: unknown[]) => void);
     /**
-     * Check if an agent can read an article.
+     * Detect cron jobs that should have fired while the daemon was down.
+     * Compares saved last-run times against the cron schedule.
      */
-    canRead(article: WikiArticleMeta, agentId: string): boolean;
+    private detectMissedRuns;
     /**
-     * Check if an agent can write an article.
+     * Execute missed runs (catch-up). Runs sequentially to avoid overwhelming agents.
      */
-    canWrite(article: WikiArticleMeta, agentId: string): boolean;
-    /**
-     * Add a raw entry (from a conversation, cron result, etc.)
-     */
-    addEntry(entry: WikiEntry): string;
-    /**
-     * List raw entries, optionally filtered by agent or date range.
-     */
-    listEntries(filter?: {
-        agentId?: string;
-        after?: string;
-        before?: string;
-    }): WikiEntry[];
-    private parseEntry;
-    /**
-     * Write or update a wiki article.
-     */
-    writeArticle(path: string, meta: WikiArticleMeta, content: string, agentId: string): boolean;
-    /**
-     * Read an article. Returns null if not found.
-     */
-    readArticle(path: string): WikiArticle | null;
-    /**
-     * Read an article with permission check.
-     */
-    readArticleAs(path: string, agentId: string): WikiArticle | null;
-    private parseArticle;
-    /**
-     * List all articles accessible to an agent.
-     */
-    listArticles(agentId: string): WikiArticle[];
-    /**
-     * Search articles by keyword. Returns articles the agent can read.
-     */
-    search(query: string, agentId: string, maxResults?: number): WikiArticle[];
-    /**
-     * Find articles relevant to a message (for context injection).
-     * Extracts keywords from the message and searches the wiki.
-     */
-    findRelevant(message: string, agentId: string, maxArticles?: number): WikiArticle[];
-    /**
-     * Build context string from relevant wiki articles for prompt injection.
-     * Token-efficient: includes title + first ~500 chars of each article.
-     */
-    buildContext(articles: WikiArticle[], maxChars?: number): string;
+    private executeMissedRuns;
+    private notifyFailure;
+    private notifyDisabled;
+    private saveLastRuns;
+    private loadLastRuns;
+    private logRun;
     /**
-     * Rebuild the master index.
+     * List all jobs and their status (including failure info).
      */
-    rebuildIndex(): WikiIndex;
+    list(): CronJobState[];
     /**
-     * Get wiki stats.
-     */
-    stats(): {
-        totalArticles: number;
-        totalEntries: number;
-        articlesByType: Record<string, number>;
-        articlesByAccess: Record<string, number>;
-        articlesByOwner: Record<string, number>;
+     * Get a health summary of cron jobs.
+     */
+    health(): {
+        healthy: number;
+        failing: number;
+        disabled: number;
+        missed: number;
+        jobs: Array<{
+            id: string;
+            status: string;
+            consecutiveErrors: number;
+            lastError?: string;
+        }>;
     };
-    /**
-     * Append an entry to log.md.
-     * Format: ## [YYYY-MM-DD HH:MM] action | details
-     */
-    appendLog(action: string, details: string): void;
-    /**
-     * Get recent log entries.
-     */
-    getLog(limit?: number): string[];
-    /**
-     * Create _schema.md if it doesn't exist.
-     * This tells the LLM how to operate on the wiki.
-     */
-    private ensureSchema;
-    /**
-     * Extract all [[wikilinks]] from article content.
-     */
-    extractWikilinks(content: string): string[];
-    /**
-     * Build backlinks index: for each article, which other articles link to it.
-     */
-    buildBacklinks(): Record<string, string[]>;
-    /**
-     * Get backlinks for a specific article title.
-     */
-    getBacklinks(title: string): string[];
-    /**
-     * Run a lint pass on the wiki. Returns issues found.
-     */
-    lint(): Array<{
-        type: string;
-        article: string;
-        message: string;
-    }>;
-    /**
-     * Get unabsorbed entries (entries not referenced by any article's sources field).
-     */
-    getUnabsorbedEntries(): WikiEntry[];
-    /**
-     * Build an absorb prompt for unprocessed entries.
-     * Returns a prompt string an agent can execute to compile entries into articles.
-     */
-    buildAbsorbPrompt(maxEntries?: number): string | null;
-    private walkDir;
 }
 
 interface ProviderCapabilities {