agentix-cli 0.9.0 → 0.14.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { IncomingMessage as IncomingMessage$1, ServerResponse } from 'http';
 import { PackageJson } from 'type-fest';
 
 interface GenerationMessage {
@@ -410,6 +411,8 @@ declare const skillFrontmatterSchema: z.ZodObject<{
         pattern: string;
         description?: string | undefined;
     }>, "many">>;
+    /** If true, skill is auto-injected into context when triggers match (per-turn) */
+    autoInject: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
@@ -421,6 +424,7 @@ declare const skillFrontmatterSchema: z.ZodObject<{
         pattern: string;
         description?: string | undefined;
     }[] | undefined;
+    autoInject?: boolean | undefined;
 }, {
     name: string;
     description: string;
@@ -432,6 +436,7 @@ declare const skillFrontmatterSchema: z.ZodObject<{
         pattern: string;
         description?: string | undefined;
     }[] | undefined;
+    autoInject?: boolean | undefined;
 }>;
 type SkillFrontmatter = z.infer<typeof skillFrontmatterSchema>;
 interface Skill {
@@ -908,7 +913,7 @@ declare class PermissionManager {
 }
 declare const globalPermissions: PermissionManager;
 
-declare const HOOK_EVENTS: readonly ["pre:generate", "post:generate", "pre:file-write", "post:file-write", "pre:prompt", "post:response", "pre:command", "on:error", "pre:tool-call", "post:tool-call", "pre:channel-message", "post:channel-message", "pre:a2a-task", "pre:cron-run", "post:cron-run"];
+declare const HOOK_EVENTS: readonly ["pre:generate", "post:generate", "pre:file-write", "post:file-write", "pre:prompt", "post:response", "pre:command", "on:error", "pre:tool-call", "post:tool-call", "pre:channel-message", "post:channel-message", "pre:a2a-task", "pre:cron-run", "post:cron-run", "on:gitlab-pipeline", "on:gitlab-issue"];
 type HookEvent = (typeof HOOK_EVENTS)[number];
 declare const BLOCKING_EVENTS: HookEvent[];
 declare const hookDefinitionSchema: z.ZodObject<{
@@ -1284,6 +1289,10 @@ declare const agentConfigSchema: z.ZodObject<{
     systemPrompt: z.ZodOptional<z.ZodString>;
     mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     maxConcurrent: z.ZodDefault<z.ZodNumber>;
+    /** Hard wall-clock cap on a single Claude Code invocation. Exceeding the
+     *  cap sends SIGTERM (exit 143). Default 20 min — bump for devops/coder
+     *  agents that do long investigations or multi-file refactors. */
+    maxExecutionMinutes: z.ZodDefault<z.ZodNumber>;
     permissionMode: z.ZodDefault<z.ZodString>;
     queueMode: z.ZodDefault<z.ZodEnum<["collect", "followup", "drop"]>>;
     heartbeat: z.ZodDefault<z.ZodObject<{
@@ -1308,6 +1317,7 @@ declare const agentConfigSchema: z.ZodObject<{
     tier: "claude-code" | "sdk" | "orchestrator";
     mentions: string[];
     maxConcurrent: number;
+    maxExecutionMinutes: number;
     permissionMode: string;
     queueMode: "collect" | "followup" | "drop";
     heartbeat: {
@@ -1328,6 +1338,7 @@ declare const agentConfigSchema: z.ZodObject<{
     systemPrompt?: string | undefined;
     mentions?: string[] | undefined;
     maxConcurrent?: number | undefined;
+    maxExecutionMinutes?: number | undefined;
     permissionMode?: string | undefined;
     queueMode?: "collect" | "followup" | "drop" | undefined;
     heartbeat?: {
@@ -1345,7 +1356,11 @@ declare const cronJobSchema: z.ZodObject<{
     prompt: z.ZodString;
     timeout: z.ZodDefault<z.ZodNumber>;
     model: z.ZodOptional<z.ZodString>;
-    onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+    /** Soft cap on output length. Claude Code CLI has no hard flag for this,
+     *  but appending an instruction to the prompt is reliably honored. Use
+     *  1500 for briefs, 500 for status pings, 300 for pure classifiers. */
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    onError: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodEnum<["log", "notify", "disable"]>, z.ZodArray<z.ZodEnum<["log", "notify", "disable"]>, "many">]>>, ("notify" | "log" | "disable")[], "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined>;
     notify: z.ZodOptional<z.ZodObject<{
         channel: z.ZodString;
         chatId: z.ZodString;
@@ -1366,13 +1381,14 @@ declare const cronJobSchema: z.ZodObject<{
     timeout: number;
     schedule: string;
     timezone: string;
-    onError: "log" | "notify" | "disable";
+    onError: ("notify" | "log" | "disable")[];
     model?: string | undefined;
     notify?: {
         channel: string;
         chatId: string;
         accountId?: string | undefined;
     } | undefined;
+    maxOutputTokens?: number | undefined;
 }, {
     agent: string;
     prompt: string;
@@ -1386,7 +1402,8 @@ declare const cronJobSchema: z.ZodObject<{
         chatId: string;
         accountId?: string | undefined;
     } | undefined;
-    onError?: "log" | "notify" | "disable" | undefined;
+    maxOutputTokens?: number | undefined;
+    onError?: "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined;
 }>;
 declare const meshPeerSchema: z.ZodObject<{
     url: z.ZodString;
@@ -1406,14 +1423,18 @@ declare const daemonConfigSchema: z.ZodObject<{
         id: z.ZodString;
         name: z.ZodString;
         bind: z.ZodDefault<z.ZodString>;
+        /** Default agent for voice/API calls that don't specify one (e.g. Siri) */
+        defaultAgent: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         name: string;
         bind: string;
+        defaultAgent?: string | undefined;
     }, {
         id: string;
         name: string;
         bind?: string | undefined;
+        defaultAgent?: string | undefined;
     }>;
     providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         apiKey: z.ZodOptional<z.ZodString>;
@@ -1437,6 +1458,10 @@ declare const daemonConfigSchema: z.ZodObject<{
         systemPrompt: z.ZodOptional<z.ZodString>;
         mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         maxConcurrent: z.ZodDefault<z.ZodNumber>;
+        /** Hard wall-clock cap on a single Claude Code invocation. Exceeding the
+         *  cap sends SIGTERM (exit 143). Default 20 min — bump for devops/coder
+         *  agents that do long investigations or multi-file refactors. */
+        maxExecutionMinutes: z.ZodDefault<z.ZodNumber>;
         permissionMode: z.ZodDefault<z.ZodString>;
         queueMode: z.ZodDefault<z.ZodEnum<["collect", "followup", "drop"]>>;
         heartbeat: z.ZodDefault<z.ZodObject<{
@@ -1461,6 +1486,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
         maxConcurrent: number;
+        maxExecutionMinutes: number;
         permissionMode: string;
         queueMode: "collect" | "followup" | "drop";
         heartbeat: {
@@ -1481,6 +1507,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         maxConcurrent?: number | undefined;
+        maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
         queueMode?: "collect" | "followup" | "drop" | undefined;
         heartbeat?: {
@@ -1607,16 +1634,23 @@ declare const daemonConfigSchema: z.ZodObject<{
                 gitlabUsernames: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                 keywords: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                 token: z.ZodOptional<z.ZodString>;
+                /** If set, the agent lives on a remote mesh peer (node id). Forces the
+                 *  username→agent map to resolve to this mapping even when a local
+                 *  agent's token resolves to the same GitLab user — prevents collisions
+                 *  like two agents both claiming @devops-noqta. */
+                node: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
                 agentId: string;
                 gitlabUsernames: string[];
                 keywords: string[];
                 token?: string | undefined;
+                node?: string | undefined;
             }, {
                 agentId: string;
                 token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
+                node?: string | undefined;
             }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
@@ -1631,6 +1665,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 gitlabUsernames: string[];
                 keywords: string[];
                 token?: string | undefined;
+                node?: string | undefined;
             }[];
             token?: string | undefined;
             webhookSecret?: string | undefined;
@@ -1649,9 +1684,28 @@ declare const daemonConfigSchema: z.ZodObject<{
                 token?: string | undefined;
                 gitlabUsernames?: string[] | undefined;
                 keywords?: string[] | undefined;
+                node?: string | undefined;
             }[] | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
+        gitlab: {
+            enabled: boolean;
+            routes: {
+                agent: string;
+                project: string;
+            }[];
+            webhookPort: number;
+            host: string;
+            agentMappings: {
+                agentId: string;
+                gitlabUsernames: string[];
+                keywords: string[];
+                token?: string | undefined;
+                node?: string | undefined;
+            }[];
+            token?: string | undefined;
+            webhookSecret?: string | undefined;
+        };
         telegram: {
             enabled: boolean;
             accounts: Record<string, {
@@ -1679,24 +1733,25 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         };
-        gitlab: {
-            enabled: boolean;
-            routes: {
+    }, {
+        gitlab?: {
+            enabled?: boolean | undefined;
+            token?: string | undefined;
+            routes?: {
                 agent: string;
                 project: string;
-            }[];
-            webhookPort: number;
-            host: string;
-            agentMappings: {
+            }[] | undefined;
+            webhookPort?: number | undefined;
+            webhookSecret?: string | undefined;
+            host?: string | undefined;
+            agentMappings?: {
                 agentId: string;
-                gitlabUsernames: string[];
-                keywords: string[];
                 token?: string | undefined;
-            }[];
-            token?: string | undefined;
-            webhookSecret?: string | undefined;
-        };
-    }, {
+                gitlabUsernames?: string[] | undefined;
+                keywords?: string[] | undefined;
+                node?: string | undefined;
+            }[] | undefined;
+        } | undefined;
         telegram?: {
             enabled?: boolean | undefined;
             accounts?: Record<string, {
@@ -1724,23 +1779,6 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         } | undefined;
-        gitlab?: {
-            enabled?: boolean | undefined;
-            token?: 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;
-        } | undefined;
     }>>;
     crons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1750,7 +1788,11 @@ declare const daemonConfigSchema: z.ZodObject<{
         prompt: z.ZodString;
         timeout: z.ZodDefault<z.ZodNumber>;
         model: z.ZodOptional<z.ZodString>;
-        onError: z.ZodDefault<z.ZodEnum<["log", "notify", "disable"]>>;
+        /** Soft cap on output length. Claude Code CLI has no hard flag for this,
+         *  but appending an instruction to the prompt is reliably honored. Use
+         *  1500 for briefs, 500 for status pings, 300 for pure classifiers. */
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        onError: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodEnum<["log", "notify", "disable"]>, z.ZodArray<z.ZodEnum<["log", "notify", "disable"]>, "many">]>>, ("notify" | "log" | "disable")[], "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined>;
         notify: z.ZodOptional<z.ZodObject<{
             channel: z.ZodString;
             chatId: z.ZodString;
@@ -1771,13 +1813,14 @@ declare const daemonConfigSchema: z.ZodObject<{
         timeout: number;
         schedule: string;
         timezone: string;
-        onError: "log" | "notify" | "disable";
+        onError: ("notify" | "log" | "disable")[];
         model?: string | undefined;
         notify?: {
             channel: string;
             chatId: string;
             accountId?: string | undefined;
         } | undefined;
+        maxOutputTokens?: number | undefined;
     }, {
         agent: string;
         prompt: string;
@@ -1791,8 +1834,128 @@ declare const daemonConfigSchema: z.ZodObject<{
             chatId: string;
             accountId?: string | undefined;
         } | undefined;
-        onError?: "log" | "notify" | "disable" | undefined;
+        maxOutputTokens?: number | undefined;
+        onError?: "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined;
+    }>>>;
+    services: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        triggers: z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            channel: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+            channel?: string | undefined;
+        }, {
+            pattern: string;
+            channel?: string | undefined;
+        }>, "many">;
+        allowedContacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+        schedule: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodDefault<z.ZodString>;
+        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, {
+        agent: string;
+        name: string;
+        prompt: string;
+        triggers: {
+            pattern: string;
+            channel?: string | undefined;
+        }[];
+        timezone: string;
+        schedule?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        allowedContacts?: string[] | undefined;
+    }, {
+        agent: string;
+        name: string;
+        prompt: string;
+        triggers: {
+            pattern: string;
+            channel?: string | undefined;
+        }[];
+        schedule?: string | undefined;
+        timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        allowedContacts?: string[] | undefined;
     }>>>;
+    notifications: z.ZodDefault<z.ZodObject<{
+        /** Send notification when task takes longer than this (seconds). 0 = disabled. */
+        longTaskThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Where to send notifications */
+        destination: 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;
+        }>>;
+        /** Notify on these events */
+        on: z.ZodDefault<z.ZodObject<{
+            taskComplete: z.ZodDefault<z.ZodBoolean>;
+            taskError: z.ZodDefault<z.ZodBoolean>;
+            taskQueued: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            taskComplete: boolean;
+            taskError: boolean;
+            taskQueued: boolean;
+        }, {
+            taskComplete?: boolean | undefined;
+            taskError?: boolean | undefined;
+            taskQueued?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        on: {
+            taskComplete: boolean;
+            taskError: boolean;
+            taskQueued: boolean;
+        };
+        longTaskThreshold: number;
+        destination?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+    }, {
+        on?: {
+            taskComplete?: boolean | undefined;
+            taskError?: boolean | undefined;
+            taskQueued?: boolean | undefined;
+        } | undefined;
+        longTaskThreshold?: number | undefined;
+        destination?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+    }>>;
     mesh: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         peers: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1844,6 +2007,408 @@ declare const daemonConfigSchema: z.ZodObject<{
             interval?: number | undefined;
         } | undefined;
     }>>;
+    business: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timezone: z.ZodDefault<z.ZodString>;
+        mainChannel: 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;
+        }>;
+        workSource: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"backlog">;
+            path: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            type: "backlog";
+        }, {
+            type: "backlog";
+            path?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"gitlab">;
+            projects: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: "gitlab";
+            projects: string[];
+        }, {
+            type: "gitlab";
+            projects?: string[] | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"wiki">;
+            path: z.ZodString;
+            glob: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            type: "wiki";
+            glob: string;
+        }, {
+            path: string;
+            type: "wiki";
+            glob?: string | undefined;
+        }>]>;
+        roles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            title: z.ZodString;
+            responsibilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            sopPath: z.ZodOptional<z.ZodString>;
+            kpis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            title: string;
+            responsibilities: string[];
+            kpis: string[];
+            sopPath?: string | undefined;
+        }, {
+            title: string;
+            responsibilities?: string[] | undefined;
+            sopPath?: string | undefined;
+            kpis?: string[] | undefined;
+        }>>>;
+        orgChart: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            role: z.ZodString;
+            reportsTo: z.ZodOptional<z.ZodString>;
+            schedule: z.ZodObject<{
+                days: z.ZodDefault<z.ZodArray<z.ZodEnum<["mon", "tue", "wed", "thu", "fri", "sat", "sun"]>, "many">>;
+                start: z.ZodString;
+                end: z.ZodString;
+                lunch: z.ZodOptional<z.ZodObject<{
+                    start: z.ZodString;
+                    end: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    end: string;
+                    start: string;
+                }, {
+                    end: string;
+                    start: string;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                end: string;
+                days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+                start: string;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            }, {
+                end: string;
+                start: string;
+                days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            }>;
+            utilizationTarget: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            role: string;
+            schedule: {
+                end: string;
+                days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+                start: string;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            utilizationTarget: number;
+            reportsTo?: string | undefined;
+        }, {
+            role: string;
+            schedule: {
+                end: string;
+                start: string;
+                days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            reportsTo?: string | undefined;
+            utilizationTarget?: number | undefined;
+        }>>>;
+        workTickMinutes: z.ZodDefault<z.ZodNumber>;
+        idleQueueThreshold: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        timezone: string;
+        mainChannel: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        };
+        workSource: {
+            path: string;
+            type: "backlog";
+        } | {
+            type: "gitlab";
+            projects: string[];
+        } | {
+            path: string;
+            type: "wiki";
+            glob: string;
+        };
+        roles: Record<string, {
+            title: string;
+            responsibilities: string[];
+            kpis: string[];
+            sopPath?: string | undefined;
+        }>;
+        orgChart: Record<string, {
+            role: string;
+            schedule: {
+                end: string;
+                days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+                start: string;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            utilizationTarget: number;
+            reportsTo?: string | undefined;
+        }>;
+        workTickMinutes: number;
+        idleQueueThreshold: number;
+    }, {
+        mainChannel: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        };
+        workSource: {
+            type: "backlog";
+            path?: string | undefined;
+        } | {
+            type: "gitlab";
+            projects?: string[] | undefined;
+        } | {
+            path: string;
+            type: "wiki";
+            glob?: string | undefined;
+        };
+        enabled?: boolean | undefined;
+        timezone?: string | undefined;
+        roles?: Record<string, {
+            title: string;
+            responsibilities?: string[] | undefined;
+            sopPath?: string | undefined;
+            kpis?: string[] | undefined;
+        }> | undefined;
+        orgChart?: Record<string, {
+            role: string;
+            schedule: {
+                end: string;
+                start: string;
+                days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            reportsTo?: string | undefined;
+            utilizationTarget?: number | undefined;
+        }> | undefined;
+        workTickMinutes?: number | undefined;
+        idleQueueThreshold?: number | undefined;
+    }>>;
+    boards: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"gitlab">;
+            projects: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            type: "gitlab";
+            projects: string[];
+        }, {
+            type: "gitlab";
+            projects: string[];
+        }>]>;
+        primaryToolLabel: z.ZodOptional<z.ZodString>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodDefault<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            color: string;
+            description?: string | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+            color?: string | undefined;
+        }>, "many">>;
+        columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<["open-backlog", "scoped-label", "closed", "label"]>>;
+            mapsToLabel: z.ZodOptional<z.ZodString>;
+            scopedLabel: z.ZodOptional<z.ZodString>;
+            scopedPrefix: z.ZodDefault<z.ZodString>;
+            accent: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            title: string;
+            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            scopedPrefix: string;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            accent?: string | undefined;
+        }, {
+            id: string;
+            title: string;
+            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            scopedPrefix?: string | undefined;
+            accent?: string | undefined;
+        }>, "many">>;
+        timeRangeDays: z.ZodDefault<z.ZodNumber>;
+        closedWindowDays: z.ZodDefault<z.ZodNumber>;
+        reconciliation: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            staleDoingMinutes: z.ZodDefault<z.ZodNumber>;
+            respectLunchBreak: z.ZodDefault<z.ZodBoolean>;
+            respectSchedule: z.ZodDefault<z.ZodBoolean>;
+            action: z.ZodDefault<z.ZodEnum<["badge", "notify"]>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            action: "badge" | "notify";
+            staleDoingMinutes: number;
+            respectLunchBreak: boolean;
+            respectSchedule: boolean;
+        }, {
+            enabled?: boolean | undefined;
+            action?: "badge" | "notify" | undefined;
+            staleDoingMinutes?: number | undefined;
+            respectLunchBreak?: boolean | undefined;
+            respectSchedule?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        source: {
+            type: "gitlab";
+            projects: string[];
+        };
+        labels: {
+            name: string;
+            color: string;
+            description?: string | undefined;
+        }[];
+        columns: {
+            id: string;
+            title: string;
+            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            scopedPrefix: string;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            accent?: string | undefined;
+        }[];
+        timeRangeDays: number;
+        closedWindowDays: number;
+        reconciliation: {
+            enabled: boolean;
+            action: "badge" | "notify";
+            staleDoingMinutes: number;
+            respectLunchBreak: boolean;
+            respectSchedule: boolean;
+        };
+        primaryToolLabel?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        source: {
+            type: "gitlab";
+            projects: string[];
+        };
+        primaryToolLabel?: string | undefined;
+        labels?: {
+            name: string;
+            description?: string | undefined;
+            color?: string | undefined;
+        }[] | undefined;
+        columns?: {
+            id: string;
+            title: string;
+            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            scopedPrefix?: string | undefined;
+            accent?: string | undefined;
+        }[] | undefined;
+        timeRangeDays?: number | undefined;
+        closedWindowDays?: number | undefined;
+        reconciliation?: {
+            enabled?: boolean | undefined;
+            action?: "badge" | "notify" | undefined;
+            staleDoingMinutes?: number | undefined;
+            respectLunchBreak?: boolean | undefined;
+            respectSchedule?: boolean | undefined;
+        } | undefined;
+    }>, "many">>;
+    dashboard: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodNumber>;
+        bind: z.ZodDefault<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        daemonUrl: z.ZodDefault<z.ZodString>;
+        daemons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+            token: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }, {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }>, "many">>;
+        draftAgent: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        port: number;
+        bind: string;
+        daemonUrl: string;
+        daemons: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[];
+        token?: string | undefined;
+        draftAgent?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        token?: string | undefined;
+        port?: number | undefined;
+        bind?: string | undefined;
+        daemonUrl?: string | undefined;
+        daemons?: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[] | undefined;
+        draftAgent?: string | undefined;
+    }>>;
+    /** Session cache-reuse policy. `staleMinutes` controls how long a Claude
+     *  session can idle before we rebuild the prompt from scratch (paying the
+     *  full cache-create tax again). Longer is cheaper at Opus rates but means
+     *  an agent may resume with mildly outdated context. */
+    session: z.ZodDefault<z.ZodObject<{
+        staleMinutes: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        staleMinutes: number;
+    }, {
+        staleMinutes?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     agents: Record<string, {
         name: string;
@@ -1851,6 +2416,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
         maxConcurrent: number;
+        maxExecutionMinutes: number;
         permissionMode: string;
         queueMode: "collect" | "followup" | "drop";
         heartbeat: {
@@ -1880,6 +2446,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         id: string;
         name: string;
         bind: string;
+        defaultAgent?: string | undefined;
     };
     providers: Record<string, {
         apiKey?: string | undefined;
@@ -1887,6 +2454,24 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseUrl?: string | undefined;
     }>;
     channels: {
+        gitlab: {
+            enabled: boolean;
+            routes: {
+                agent: string;
+                project: string;
+            }[];
+            webhookPort: number;
+            host: string;
+            agentMappings: {
+                agentId: string;
+                gitlabUsernames: string[];
+                keywords: string[];
+                token?: string | undefined;
+                node?: string | undefined;
+            }[];
+            token?: string | undefined;
+            webhookSecret?: string | undefined;
+        };
         telegram: {
             enabled: boolean;
             accounts: Record<string, {
@@ -1914,23 +2499,6 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         };
-        gitlab: {
-            enabled: boolean;
-            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;
-        };
     };
     crons: Record<string, {
         enabled: boolean;
@@ -1939,19 +2507,141 @@ declare const daemonConfigSchema: z.ZodObject<{
         timeout: number;
         schedule: string;
         timezone: string;
-        onError: "log" | "notify" | "disable";
+        onError: ("notify" | "log" | "disable")[];
         model?: string | undefined;
         notify?: {
             channel: string;
             chatId: string;
             accountId?: string | undefined;
         } | undefined;
+        maxOutputTokens?: number | undefined;
+    }>;
+    services: Record<string, {
+        agent: string;
+        name: string;
+        prompt: string;
+        triggers: {
+            pattern: string;
+            channel?: string | undefined;
+        }[];
+        timezone: string;
+        schedule?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        allowedContacts?: string[] | undefined;
     }>;
+    notifications: {
+        on: {
+            taskComplete: boolean;
+            taskError: boolean;
+            taskQueued: boolean;
+        };
+        longTaskThreshold: number;
+        destination?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+    };
+    boards: {
+        id: string;
+        name: string;
+        source: {
+            type: "gitlab";
+            projects: string[];
+        };
+        labels: {
+            name: string;
+            color: string;
+            description?: string | undefined;
+        }[];
+        columns: {
+            id: string;
+            title: string;
+            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            scopedPrefix: string;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            accent?: string | undefined;
+        }[];
+        timeRangeDays: number;
+        closedWindowDays: number;
+        reconciliation: {
+            enabled: boolean;
+            action: "badge" | "notify";
+            staleDoingMinutes: number;
+            respectLunchBreak: boolean;
+            respectSchedule: boolean;
+        };
+        primaryToolLabel?: string | undefined;
+    }[];
+    dashboard: {
+        enabled: boolean;
+        port: number;
+        bind: string;
+        daemonUrl: string;
+        daemons: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[];
+        token?: string | undefined;
+        draftAgent?: string | undefined;
+    };
+    session: {
+        staleMinutes: number;
+    };
+    business?: {
+        enabled: boolean;
+        timezone: string;
+        mainChannel: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        };
+        workSource: {
+            path: string;
+            type: "backlog";
+        } | {
+            type: "gitlab";
+            projects: string[];
+        } | {
+            path: string;
+            type: "wiki";
+            glob: string;
+        };
+        roles: Record<string, {
+            title: string;
+            responsibilities: string[];
+            kpis: string[];
+            sopPath?: string | undefined;
+        }>;
+        orgChart: Record<string, {
+            role: string;
+            schedule: {
+                end: string;
+                days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+                start: string;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            utilizationTarget: number;
+            reportsTo?: string | undefined;
+        }>;
+        workTickMinutes: number;
+        idleQueueThreshold: number;
+    } | undefined;
 }, {
     node: {
         id: string;
         name: string;
         bind?: string | undefined;
+        defaultAgent?: string | undefined;
     };
     agents?: Record<string, {
         name: string;
@@ -1962,6 +2652,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         maxConcurrent?: number | undefined;
+        maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
         queueMode?: "collect" | "followup" | "drop" | undefined;
         heartbeat?: {
@@ -1990,6 +2681,24 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseUrl?: string | undefined;
     }> | undefined;
     channels?: {
+        gitlab?: {
+            enabled?: boolean | undefined;
+            token?: 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;
+                node?: string | undefined;
+            }[] | undefined;
+        } | undefined;
         telegram?: {
             enabled?: boolean | undefined;
             accounts?: Record<string, {
@@ -2017,39 +2726,143 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         } | undefined;
-        gitlab?: {
-            enabled?: boolean | undefined;
-            token?: 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;
+    } | undefined;
+    crons?: Record<string, {
+        agent: string;
+        prompt: string;
+        schedule: string;
+        model?: string | undefined;
+        enabled?: boolean | undefined;
+        timeout?: number | undefined;
+        timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        maxOutputTokens?: number | undefined;
+        onError?: "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined;
+    }> | undefined;
+    services?: Record<string, {
+        agent: string;
+        name: string;
+        prompt: string;
+        triggers: {
+            pattern: string;
+            channel?: string | undefined;
+        }[];
+        schedule?: string | undefined;
+        timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        allowedContacts?: string[] | undefined;
+    }> | undefined;
+    notifications?: {
+        on?: {
+            taskComplete?: boolean | undefined;
+            taskError?: boolean | undefined;
+            taskQueued?: boolean | undefined;
+        } | undefined;
+        longTaskThreshold?: number | undefined;
+        destination?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+    } | undefined;
+    business?: {
+        mainChannel: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        };
+        workSource: {
+            type: "backlog";
+            path?: string | undefined;
+        } | {
+            type: "gitlab";
+            projects?: string[] | undefined;
+        } | {
+            path: string;
+            type: "wiki";
+            glob?: string | undefined;
+        };
+        enabled?: boolean | undefined;
+        timezone?: string | undefined;
+        roles?: Record<string, {
+            title: string;
+            responsibilities?: string[] | undefined;
+            sopPath?: string | undefined;
+            kpis?: string[] | undefined;
+        }> | undefined;
+        orgChart?: Record<string, {
+            role: string;
+            schedule: {
+                end: string;
+                start: string;
+                days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+                lunch?: {
+                    end: string;
+                    start: string;
+                } | undefined;
+            };
+            reportsTo?: string | undefined;
+            utilizationTarget?: number | undefined;
+        }> | undefined;
+        workTickMinutes?: number | undefined;
+        idleQueueThreshold?: number | undefined;
+    } | undefined;
+    boards?: {
+        id: string;
+        name: string;
+        source: {
+            type: "gitlab";
+            projects: string[];
+        };
+        primaryToolLabel?: string | undefined;
+        labels?: {
+            name: string;
+            description?: string | undefined;
+            color?: string | undefined;
+        }[] | undefined;
+        columns?: {
+            id: string;
+            title: string;
+            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            mapsToLabel?: string | undefined;
+            scopedLabel?: string | undefined;
+            scopedPrefix?: string | undefined;
+            accent?: string | undefined;
+        }[] | undefined;
+        timeRangeDays?: number | undefined;
+        closedWindowDays?: number | undefined;
+        reconciliation?: {
+            enabled?: boolean | undefined;
+            action?: "badge" | "notify" | undefined;
+            staleDoingMinutes?: number | undefined;
+            respectLunchBreak?: boolean | undefined;
+            respectSchedule?: boolean | undefined;
         } | undefined;
-    } | undefined;
-    crons?: Record<string, {
-        agent: string;
-        prompt: string;
-        schedule: string;
-        model?: string | undefined;
+    }[] | undefined;
+    dashboard?: {
         enabled?: boolean | undefined;
-        timeout?: number | undefined;
-        timezone?: string | undefined;
-        notify?: {
-            channel: string;
-            chatId: string;
-            accountId?: string | undefined;
-        } | undefined;
-        onError?: "log" | "notify" | "disable" | undefined;
-    }> | undefined;
+        token?: string | undefined;
+        port?: number | undefined;
+        bind?: string | undefined;
+        daemonUrl?: string | undefined;
+        daemons?: {
+            name: string;
+            url: string;
+            token?: string | undefined;
+        }[] | undefined;
+        draftAgent?: string | undefined;
+    } | undefined;
+    session?: {
+        staleMinutes?: number | undefined;
+    } | undefined;
 }>;
 type DaemonConfig = z.infer<typeof daemonConfigSchema>;
 type AgentDef = z.infer<typeof agentConfigSchema>;
@@ -2119,14 +2932,35 @@ declare class AgentXDaemon {
     private hooks;
     private landscape;
     private heartbeat;
+    private business?;
     private httpServer?;
     private webhooks;
     private log;
     private sseClients;
+    private configPath?;
+    private configWatcher?;
+    private reloadTimer?;
     constructor(configPath?: string);
     start(): Promise<void>;
     stop(): Promise<void>;
     private midnightTimer?;
+    /**
+     * Watch agentx.json for external edits (e.g. `agentx config set ...`) and
+     * reload cron jobs + in-memory config. Channels / agents / mesh changes
+     * still require a restart — we log a warning so the operator knows.
+     */
+    private startConfigWatcher;
+    /**
+     * Re-read agentx.json, diff against the in-memory config, apply what we
+     * can hot-reload (crons, notify-destination, business metadata), and warn
+     * about sections that require a daemon restart (channels, agents, mesh,
+     * node.bind, providers).
+     */
+    reload(): Promise<{
+        applied: string[];
+        restartRequired: string[];
+        error?: string;
+    }>;
     private scheduleMidnightHook;
     private runDailyCostReport;
     private startChannels;
@@ -2156,9 +2990,24 @@ declare class AgentXDaemon {
     private json;
 }
 
-interface DailyUsage {
-    date: string;
-    agents: Record<string, AgentUsage>;
+declare const CACHE_AWARE_PRICING: Record<string, {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreate: number;
+}>;
+interface ChannelUsage {
+    tasks: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreateTokens: number;
+    tier2InputTokens: number;
+    tier2OutputTokens: number;
+    tier2CacheReadTokens: number;
+    tier2CacheCreateTokens: number;
+    totalDuration: number;
+    errors: number;
 }
 interface AgentUsage {
     tasks: number;
@@ -2166,9 +3015,26 @@ interface AgentUsage {
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreateTokens: number;
+    /** Tokens from requests whose input crossed CONTEXT_TIER_THRESHOLD (billed at
+     *  TIER2_MULTIPLIER × normal rate). Kept separate from the tier1 buckets so
+     *  cost math stays honest when a session accumulates past 200K. */
+    tier2InputTokens?: number;
+    tier2OutputTokens?: number;
+    tier2CacheReadTokens?: number;
+    tier2CacheCreateTokens?: number;
     totalDuration: number;
     errors: number;
     model?: string;
+    /** Per-channel breakdown so we can attribute cost to Telegram vs GitLab vs WhatsApp. */
+    byChannel?: Record<string, ChannelUsage>;
+    /** Unique session identifiers (channel:chatId) this agent participated in
+     *  today. Used to derive avg tasks/session. Capped at 500 entries to keep
+     *  the daily JSON small. */
+    sessionKeys?: string[];
+}
+interface DailyUsage {
+    date: string;
+    agents: Record<string, AgentUsage>;
 }
 interface DailyReport {
     date: string;
@@ -2181,24 +3047,50 @@ interface DailyReport {
     topAgent: string;
     topCost: number;
     agentCosts: Record<string, number>;
+    /** Per-agent avg tasks/session — high values suggest retry chains. */
+    agentSessionStats: Record<string, {
+        sessions: number;
+        avgTasksPerSession: number;
+    }>;
+    /** Aggregate cost by channel across all agents. */
+    byChannel: Record<string, number>;
+}
+/** Shape of a per-request usage report coming from the runtime. Keeps the
+ *  record() signature tidy and lets callers opt into tier2 accounting. */
+interface TaskUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreateTokens: number;
 }
 declare class TokenTracker {
     private dir;
     private cache;
+    private pricing;
     constructor(baseDir?: string);
+    /** Returns the active pricing table (hardcoded defaults with any per-model
+     *  overrides merged in). Useful for UI / debugging. */
+    getPricing(): typeof CACHE_AWARE_PRICING;
+    /**
+     * Calculate cost for a slice of usage. Accepts either a full AgentUsage or
+     * a narrowed ChannelUsage — both expose the same token buckets we price on.
+     * Tier2 tokens are billed at TIER2_MULTIPLIER × the normal rate.
+     */
+    static calculateCost(usage: AgentUsage | ChannelUsage, model?: string, pricingTable?: typeof CACHE_AWARE_PRICING): number;
     /**
-     * Calculate cost for an agent's usage with cache-aware pricing.
+     * Instance-level cost calculation — uses the tracker's resolved pricing
+     * table so any custom override file is honored. Prefer this over the
+     * static variant when available.
      */
-    static calculateCost(usage: AgentUsage): number;
+    cost(usage: AgentUsage | ChannelUsage, model?: string): number;
     /**
      * Record a task execution with real or estimated token counts.
+     *
+     * `channel` attributes the cost to a surface (telegram/gitlab/whatsapp/cron).
+     * `sessionKey` is an opaque "this chat on this day" identifier — we use it
+     * to count unique sessions so an avg-tasks-per-session metric falls out.
      */
-    record(agentId: string, duration: number, realUsage?: {
-        inputTokens: number;
-        outputTokens: number;
-        cacheReadTokens: number;
-        cacheCreateTokens: number;
-    }, messageLength?: number, responseLength?: number, error?: boolean, model?: string): void;
+    record(agentId: string, duration: number, realUsage?: TaskUsage, messageLength?: number, responseLength?: number, error?: boolean, model?: string, channel?: string, sessionKey?: string): void;
     /**
      * Get today's usage summary.
      */
@@ -2208,11 +3100,13 @@ declare class TokenTracker {
      */
     getDate(date: string): DailyUsage | null;
     /**
-     * Generate a daily cost report for a given date.
+     * Generate a daily cost report for a given date. Includes per-agent,
+     * per-channel costs and session statistics.
      */
     generateDailyReport(date?: string): DailyReport | null;
     /**
-     * Append a daily report row to TOKEN_COSTS.md.
+     * Append a daily report row to TOKEN_COSTS.md. Adds channel + session
+     * breakdown inline for at-a-glance spend attribution.
      */
     appendToTokenCosts(report: DailyReport, filePath?: string): void;
     /**
@@ -2238,6 +3132,14 @@ declare class TokenTracker {
             avgDuration: number;
             cost: number;
         }>;
+        byChannel: Record<string, {
+            tasks: number;
+            cost: number;
+        }>;
+        sessionStats: Record<string, {
+            sessions: number;
+            avgTasksPerSession: number;
+        }>;
     };
     private filePath;
     private save;
@@ -2252,6 +3154,13 @@ interface AgentPeer {
 interface AgentTask {
     message: string;
     agentId: string;
+    /** Per-invocation model override (e.g. cron model). Falls back to agent.model. */
+    model?: string;
+    /** Cacheable text delivered to Claude via --append-system-prompt. Typically
+     *  agent.systemPrompt + SOUL/IDENTITY/AGENTS.md. Passing stable content
+     *  here (instead of in the user-message body) keeps it inside Claude's
+     *  cached system prompt across session resumes. */
+    systemPromptAppend?: string;
     context?: {
         channel?: string;
         sender?: string;
@@ -2299,6 +3208,12 @@ interface AgentResponse {
     duration?: number;
     claudeSessionId?: string;
     usage?: TokenUsage;
+    /** The model Claude actually billed for (from the CLI's init event). When
+     *  absent, cost reporting should fall back to the model override / agent
+     *  config. Knowing the billed model is what makes cache-aware pricing
+     *  trustworthy — a task that ran sonnet but was logged as opus would
+     *  overstate cost by ~5×. */
+    billedModel?: string;
 }
 /** Callback for streaming text deltas */
 type StreamCallback = (delta: string, fullText: string) => void;
@@ -2320,11 +3235,11 @@ declare function executeClaudeCode(agent: AgentDef, task: AgentTask, historyCont
 /**
  * Execute a task using the Claude Agent SDK (tier: "sdk").
  */
-declare function executeSdk(agent: AgentDef, task: AgentTask, apiKey: string): Promise<AgentResponse>;
+declare function executeSdk(agent: AgentDef, task: AgentTask, apiKey: string, historyContext?: string): Promise<AgentResponse>;
 /**
  * Execute a task using agentx's own orchestrator (tier: "orchestrator").
  */
-declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?: string): Promise<AgentResponse>;
+declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?: string, historyContext?: string): Promise<AgentResponse>;
 /**
  * Route a task to the correct execution tier.
  */
@@ -2406,6 +3321,22 @@ declare class WikiStore {
      * Write or update a wiki article.
      */
     writeArticle(path: string, meta: WikiArticleMeta, content: string, agentId: string): boolean;
+    /**
+     * Save current article content as an immutable version before overwriting.
+     * Versions stored in _versions/{article-path}/{timestamp}.md
+     */
+    private saveVersion;
+    /**
+     * List all versions of an article (newest first).
+     */
+    getVersions(articlePath: string): Array<{
+        timestamp: string;
+        path: string;
+    }>;
+    /**
+     * Restore a specific version of an article.
+     */
+    restoreVersion(articlePath: string, versionTimestamp: string): boolean;
     /**
      * Read an article. Returns null if not found.
      */
@@ -2575,16 +3506,26 @@ declare class LandscapeBuilder {
     private config;
     private meshPeers;
     constructor(config: DaemonConfig);
+    /** Fingerprint of the peer set that produced the current cache. A rebuild
+     *  is skipped when `refresh()` gets a topologically-identical set — this
+     *  is the common case on every mesh heartbeat and rebuilding would
+     *  needlessly invalidate every agent's cached prompt prefix. */
+    private fingerprint;
     /**
      * Build landscape strings for all agents. Call at startup.
      */
     build(meshPeers?: MeshPeerInfo[]): void;
+    /** Set-only signature of peers + their skill IDs. Health is excluded on
+     *  purpose — we don't want a flapping heartbeat to rebuild the cache. */
+    private computeFingerprint;
     /**
      * Get the cached landscape string for a specific agent.
      */
     getForAgent(agentId: string): string | undefined;
     /**
-     * Rebuild after mesh topology changes.
+     * Rebuild after mesh topology changes. Skipped when the peer set is
+     * unchanged so a flapping health heartbeat doesn't invalidate every
+     * agent's cached prompt prefix.
      */
     refresh(meshPeers: MeshPeerInfo[]): void;
     private renderForAgent;
@@ -2600,6 +3541,20 @@ declare class LandscapeBuilder {
     private extractCapability;
 }
 
+interface RunningTask {
+    /** Unique id for this execution (timestamp-based). */
+    id: string;
+    /** First 200 chars of the user message, for display. */
+    messagePreview: string;
+    /** Origin channel (telegram, whatsapp, gitlab, api, cron, business, a2a, …). */
+    channel: string;
+    /** Group / chat / issue id from which the task arrived. */
+    chatId?: string;
+    /** Sender id/name (user, agent id, "cron:<id>", "mesh:<peer>", …). */
+    sender?: string;
+    /** Wall-clock start. */
+    startedAt: Date;
+}
 declare class AgentRegistry {
     private agents;
     private config;
@@ -2607,10 +3562,13 @@ declare class AgentRegistry {
     private sessions;
     private wikiHub;
     private memoryStore;
+    private patternStore;
     private rateLimiter;
     private tokenTracker;
     private landscape?;
     private messageQueue;
+    /** Active soul profile per agent+chat session: "agentId:channel:chatId" → profile name */
+    private activeSouls;
     private log;
     constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
     /**
@@ -2624,8 +3582,17 @@ declare class AgentRegistry {
     /**
      * Find agent by mention pattern (e.g., "@my_bot" -> "my-agent").
      * Returns the agent with the longest (most specific) mention match.
+     *
+     * When `atMentionsOnly` is true, only `@`-prefixed mentions are considered.
+     * This is used for messages originating from another bot (cross-daemon
+     * Telegram cascades, for example) where we don't want bare-word matches
+     * like "nadia" in prose or "devops-mtgl" quoted in a reply to trigger
+     * agents spuriously. Intentional handoffs still work because agents
+     * write explicit `@noqta_X_bot` handles.
      */
-    findByMention(text: string): string | undefined;
+    findByMention(text: string, opts?: {
+        atMentionsOnly?: boolean;
+    }): string | undefined;
     /**
      * Find ALL agents mentioned in text (for bot-to-bot detection).
      */
@@ -2651,11 +3618,13 @@ declare class AgentRegistry {
         id: string;
         name: string;
         tier: string;
+        model?: string;
         workspace: string;
         active: number;
         total: number;
         errors: number;
         lastActive?: Date;
+        runningTasks: RunningTask[];
     }>;
     /**
      * Get token usage summary.
@@ -2680,6 +3649,14 @@ declare class AgentRegistry {
             avgDuration: number;
             cost: number;
         }>;
+        byChannel: Record<string, {
+            tasks: number;
+            cost: number;
+        }>;
+        sessionStats: Record<string, {
+            sessions: number;
+            avgTasksPerSession: number;
+        }>;
     };
     /**
      * Get today's usage.
@@ -2723,6 +3700,10 @@ interface IncomingMessage {
         id: string;
         name: string;
         username?: string;
+        /** True when the origin is another bot account (Telegram `from.is_bot`).
+         *  Used by the router to apply strict @-mention-only routing — prevents
+         *  cross-daemon cascades from bare-word matches in bot replies. */
+        isBot?: boolean;
     };
     group?: {
         id: string;
@@ -2739,6 +3720,7 @@ interface IncomingMessage {
     };
     raw?: unknown;
     resolvedAgent?: string;
+    preferNode?: string;
     channelMeta?: ChannelMeta;
 }
 interface OutgoingMessage {
@@ -2769,16 +3751,623 @@ interface ChannelAdapter {
     getChannelMeta?(chatId: string): Promise<ChannelMeta | undefined>;
 }
 
+interface ServiceTrigger {
+    pattern: string;
+    channel?: string;
+}
+interface ServiceNotify {
+    channel: string;
+    chatId: string;
+    accountId?: string;
+}
+interface ServiceDef {
+    id: string;
+    name: string;
+    triggers: ServiceTrigger[];
+    allowedContacts?: string[];
+    agent: string;
+    prompt: string;
+    schedule?: string;
+    timezone?: string;
+    notify?: ServiceNotify;
+}
+interface ServiceMatch {
+    service: ServiceDef;
+    trigger: string;
+    captured: string;
+}
+declare class ServiceMatcher {
+    private services;
+    private log;
+    constructor(serviceDefs: Record<string, Omit<ServiceDef, "id">>, log?: (...args: unknown[]) => void);
+    /**
+     * Match an incoming message against all service triggers.
+     * Returns the first matching service or null.
+     */
+    match(text: string, senderId: string, channel: string): ServiceMatch | null;
+    /**
+     * Execute a matched service.
+     * Sends the service's predefined prompt to the agent, returns the response.
+     */
+    execute(service: ServiceDef, registry: AgentRegistry, context: {
+        channel: string;
+        sender: string;
+        chatId: string;
+    }, replyFn: (text: string) => Promise<void>): Promise<void>;
+    /**
+     * Get all services that have a schedule (for cron registration).
+     */
+    getScheduledServices(): ServiceDef[];
+    /**
+     * List all registered services.
+     */
+    list(): Array<{
+        id: string;
+        name: string;
+        triggers: number;
+        agent: string;
+        scheduled: boolean;
+    }>;
+}
+
+declare const roleSchema: z.ZodObject<{
+    title: z.ZodString;
+    responsibilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sopPath: z.ZodOptional<z.ZodString>;
+    kpis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    responsibilities: string[];
+    kpis: string[];
+    sopPath?: string | undefined;
+}, {
+    title: string;
+    responsibilities?: string[] | undefined;
+    sopPath?: string | undefined;
+    kpis?: string[] | undefined;
+}>;
+declare const orgEntrySchema: z.ZodObject<{
+    role: z.ZodString;
+    reportsTo: z.ZodOptional<z.ZodString>;
+    schedule: z.ZodObject<{
+        days: z.ZodDefault<z.ZodArray<z.ZodEnum<["mon", "tue", "wed", "thu", "fri", "sat", "sun"]>, "many">>;
+        start: z.ZodString;
+        end: z.ZodString;
+        lunch: z.ZodOptional<z.ZodObject<{
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            end: string;
+            start: string;
+        }, {
+            end: string;
+            start: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        end: string;
+        days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+        start: string;
+        lunch?: {
+            end: string;
+            start: string;
+        } | undefined;
+    }, {
+        end: string;
+        start: string;
+        days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+        lunch?: {
+            end: string;
+            start: string;
+        } | undefined;
+    }>;
+    utilizationTarget: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    schedule: {
+        end: string;
+        days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+        start: string;
+        lunch?: {
+            end: string;
+            start: string;
+        } | undefined;
+    };
+    utilizationTarget: number;
+    reportsTo?: string | undefined;
+}, {
+    role: string;
+    schedule: {
+        end: string;
+        start: string;
+        days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+        lunch?: {
+            end: string;
+            start: string;
+        } | undefined;
+    };
+    reportsTo?: string | undefined;
+    utilizationTarget?: number | undefined;
+}>;
+declare const businessConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    timezone: z.ZodDefault<z.ZodString>;
+    mainChannel: 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;
+    }>;
+    workSource: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"backlog">;
+        path: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: "backlog";
+    }, {
+        type: "backlog";
+        path?: string | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"gitlab">;
+        projects: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "gitlab";
+        projects: string[];
+    }, {
+        type: "gitlab";
+        projects?: string[] | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"wiki">;
+        path: z.ZodString;
+        glob: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: "wiki";
+        glob: string;
+    }, {
+        path: string;
+        type: "wiki";
+        glob?: string | undefined;
+    }>]>;
+    roles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodString;
+        responsibilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        sopPath: z.ZodOptional<z.ZodString>;
+        kpis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        responsibilities: string[];
+        kpis: string[];
+        sopPath?: string | undefined;
+    }, {
+        title: string;
+        responsibilities?: string[] | undefined;
+        sopPath?: string | undefined;
+        kpis?: string[] | undefined;
+    }>>>;
+    orgChart: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        role: z.ZodString;
+        reportsTo: z.ZodOptional<z.ZodString>;
+        schedule: z.ZodObject<{
+            days: z.ZodDefault<z.ZodArray<z.ZodEnum<["mon", "tue", "wed", "thu", "fri", "sat", "sun"]>, "many">>;
+            start: z.ZodString;
+            end: z.ZodString;
+            lunch: z.ZodOptional<z.ZodObject<{
+                start: z.ZodString;
+                end: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                end: string;
+                start: string;
+            }, {
+                end: string;
+                start: string;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            end: string;
+            days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+            start: string;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        }, {
+            end: string;
+            start: string;
+            days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        }>;
+        utilizationTarget: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        schedule: {
+            end: string;
+            days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+            start: string;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        };
+        utilizationTarget: number;
+        reportsTo?: string | undefined;
+    }, {
+        role: string;
+        schedule: {
+            end: string;
+            start: string;
+            days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        };
+        reportsTo?: string | undefined;
+        utilizationTarget?: number | undefined;
+    }>>>;
+    /** Work-tick cadence in minutes during business hours. Default 15. */
+    workTickMinutes: z.ZodDefault<z.ZodNumber>;
+    /** Max queue depth for an idle agent before skipping the work tick (avoids piling up). */
+    idleQueueThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    timezone: string;
+    mainChannel: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    };
+    workSource: {
+        path: string;
+        type: "backlog";
+    } | {
+        type: "gitlab";
+        projects: string[];
+    } | {
+        path: string;
+        type: "wiki";
+        glob: string;
+    };
+    roles: Record<string, {
+        title: string;
+        responsibilities: string[];
+        kpis: string[];
+        sopPath?: string | undefined;
+    }>;
+    orgChart: Record<string, {
+        role: string;
+        schedule: {
+            end: string;
+            days: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[];
+            start: string;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        };
+        utilizationTarget: number;
+        reportsTo?: string | undefined;
+    }>;
+    workTickMinutes: number;
+    idleQueueThreshold: number;
+}, {
+    mainChannel: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    };
+    workSource: {
+        type: "backlog";
+        path?: string | undefined;
+    } | {
+        type: "gitlab";
+        projects?: string[] | undefined;
+    } | {
+        path: string;
+        type: "wiki";
+        glob?: string | undefined;
+    };
+    enabled?: boolean | undefined;
+    timezone?: string | undefined;
+    roles?: Record<string, {
+        title: string;
+        responsibilities?: string[] | undefined;
+        sopPath?: string | undefined;
+        kpis?: string[] | undefined;
+    }> | undefined;
+    orgChart?: Record<string, {
+        role: string;
+        schedule: {
+            end: string;
+            start: string;
+            days?: ("mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun")[] | undefined;
+            lunch?: {
+                end: string;
+                start: string;
+            } | undefined;
+        };
+        reportsTo?: string | undefined;
+        utilizationTarget?: number | undefined;
+    }> | undefined;
+    workTickMinutes?: number | undefined;
+    idleQueueThreshold?: number | undefined;
+}>;
+type BusinessConfig = z.infer<typeof businessConfigSchema>;
+type BusinessRole = z.infer<typeof roleSchema>;
+type BusinessOrgEntry = z.infer<typeof orgEntrySchema>;
+
+interface EmployeeProfile {
+    agentId: string;
+    role: BusinessRole;
+    roleKey: string;
+    reportsTo?: string;
+    schedule: BusinessOrgEntry["schedule"];
+    utilizationTarget: number;
+}
+declare class Organization {
+    private employees;
+    constructor(config: BusinessConfig);
+    get(agentId: string): EmployeeProfile | undefined;
+    all(): EmployeeProfile[];
+    reportsTo(agentId: string): string | undefined;
+    directReports(agentId: string): string[];
+    /** Walk up the org tree to the root. First element is `agentId` itself. */
+    chainOfCommand(agentId: string): string[];
+}
+
+declare class Schedule {
+    private org;
+    private config;
+    constructor(org: Organization, config: BusinessConfig);
+    isOnClock(agentId: string, when?: Date): boolean;
+    /** Is `when` exactly (to the minute) the scheduled day-start for this agent? */
+    isDayStart(agentId: string, when?: Date): boolean;
+    /** Is `when` exactly the scheduled day-end for this agent? */
+    isDayEnd(agentId: string, when?: Date): boolean;
+    clockedInAgents(when?: Date): string[];
+}
+
+interface WorkItem {
+    id: string;
+    title: string;
+    description?: string;
+    assignee?: string;
+    estimatedSeconds?: number;
+    url?: string;
+    priority?: number;
+    /** Board stage derived from labels (kanban column id). */
+    stage?: "triage" | "todo" | "doing" | "onhold" | "review" | "done";
+    /** Raw labels from the source (GitLab). Empty array if source doesn't support labels. */
+    labels?: string[];
+    /** Label name+color when the source returns colored labels (GitLab with_labels_details). */
+    labelDetails?: Array<{
+        name: string;
+        color: string;
+        text_color?: string;
+    }>;
+    /** ISO timestamp of last update on the source. */
+    updatedAt?: string;
+    /** Open/closed state from the source. */
+    state?: "opened" | "closed";
+    /** Optional milestone title (GitLab: issue.milestone.title). */
+    milestone?: string;
+    /** GitLab assignees (0..n). `assignee` above is the agentId alias for assignees[0]. */
+    assignees?: Array<{
+        username: string;
+        name?: string;
+        avatarUrl?: string;
+    }>;
+}
+interface WorkReport {
+    status: "in-progress" | "done" | "blocked";
+    note?: string;
+    timeSeconds?: number;
+    blocker?: string;
+}
+/** What a WorkSource can do beyond the minimal listOpen/claim/report triple. */
+interface WorkSourceCapabilities {
+    /** Enumerate items beyond assignee filter — required for a board view. */
+    listAll: boolean;
+    /** Create new items (e.g. POST GitLab issue). */
+    create: boolean;
+    /** Arbitrary column transitions (label add/remove pair). */
+    transition: boolean;
+    /** Surfaces labels[] on returned items. */
+    labels: boolean;
+    /** Server-side text search. */
+    search: boolean;
+}
+interface WorkCreateInput {
+    title: string;
+    description?: string;
+    /** agentId */
+    assignee?: string;
+    /** Raw GitLab usernames — bypass agentId resolution for UI-driven creates. */
+    assigneeUsernames?: string[];
+    labels?: string[];
+    /** Milestone title (resolved to id). */
+    milestoneTitle?: string;
+    /** For sources that span multiple projects (gitlab): "group/project". */
+    projectHint?: string;
+}
+interface ListAllOpts {
+    sinceDays?: number;
+    labels?: string[];
+    /** Exclude items carrying any of these labels (client-side filter). */
+    notLabels?: string[];
+    /** Exclude items whose labels carry this scoped prefix (e.g. "Status"). */
+    withoutScopedPrefix?: string;
+    search?: string;
+    assignee?: string;
+    /** GitLab issue state. Defaults to "opened" (boards hide closed issues). */
+    state?: "opened" | "closed" | "all";
+    /** Milestone filter (GitLab "milestone" query param). */
+    milestone?: string;
+}
+interface WorkSource {
+    type: string;
+    capabilities: WorkSourceCapabilities;
+    listOpen(agentId: string): Promise<WorkItem[]>;
+    claim(agentId: string, itemId: string): Promise<void>;
+    report(itemId: string, update: WorkReport): Promise<void>;
+    /** Optional — gated by capabilities.listAll. */
+    listAll?(opts: ListAllOpts): Promise<WorkItem[]>;
+    /** Optional — gated by capabilities.create. */
+    create?(input: WorkCreateInput): Promise<WorkItem>;
+    /**
+     * Optional — gated by capabilities.transition. Add `toLabel` and remove
+     * `fromLabel` (if provided) from the item. Used by the kanban board on drag.
+     */
+    transition?(itemId: string, toLabel: string, fromLabel?: string): Promise<void>;
+}
+
+declare class Reporter {
+    private router;
+    private org;
+    private config;
+    private log;
+    constructor(router: MessageRouter, org: Organization, config: BusinessConfig, log: (...args: unknown[]) => void);
+    postToMain(text: string, agentId?: string): Promise<void>;
+    /** Post an escalation message up the chain of command. */
+    escalate(fromAgent: string, subject: string, detail: string): Promise<void>;
+}
+
+interface DailyStats {
+    date: string;
+    perAgent: Record<string, {
+        tasksCompleted: number;
+        timeLoggedSeconds: number;
+        onClockSeconds: number;
+        blockers: number;
+        utilization: number;
+    }>;
+}
+interface TaskCompletion {
+    agentId: string;
+    durationSeconds: number;
+    success: boolean;
+    channel?: string;
+}
+declare class KPI {
+    private org;
+    private schedule;
+    private log;
+    private stats;
+    private dir;
+    private onClockTick;
+    constructor(org: Organization, schedule: Schedule, log: (...args: unknown[]) => void);
+    private loadOrInit;
+    /** Called by the day-cycle minute tick to accumulate on-clock time. */
+    tick(): void;
+    recordTaskCompletion(t: TaskCompletion): void;
+    recordBlocker(agentId: string): void;
+    private recomputeUtil;
+    private persist;
+    flush(): void;
+    snapshot(): DailyStats;
+    /** Markdown summary for end-of-day main-channel post. */
+    dailySummaryText(): string;
+}
+
+declare class DayCycle {
+    private config;
+    private org;
+    private schedule;
+    private registry;
+    private reporter;
+    private kpi;
+    private workSource;
+    private daemonBase;
+    private log;
+    private timer?;
+    private day;
+    private currentDate;
+    private runningTask;
+    constructor(config: BusinessConfig, org: Organization, schedule: Schedule, registry: AgentRegistry, reporter: Reporter, kpi: KPI, workSource: WorkSource, daemonBase: string, log: (...args: unknown[]) => void);
+    start(): void;
+    stop(): void;
+    private tick;
+    private roleContext;
+    private runLifecycle;
+    private fireStandup;
+    private fireWorkTick;
+    private fireWrap;
+}
+
+/**
+ * Business layer facade — constructed once by the daemon when
+ * config.business?.enabled is true.
+ */
+declare class BusinessLayer {
+    readonly org: Organization;
+    readonly schedule: Schedule;
+    readonly workSource: WorkSource;
+    readonly reporter: Reporter;
+    readonly kpi: KPI;
+    readonly dayCycle: DayCycle;
+    constructor(business: BusinessConfig, daemon: DaemonConfig, registry: AgentRegistry, router: MessageRouter, log: (...args: unknown[]) => void);
+    start(): void;
+    stop(): void;
+    /** Record a task completion (called by router when an agent finishes a task). */
+    recordTaskCompletion(agentId: string, durationSeconds: number, success: boolean, channel?: string): void;
+    handleHttp(route: string, req: IncomingMessage$1, res: ServerResponse): Promise<boolean>;
+    /** Short startup banner line. */
+    summary(): string;
+}
+
 declare class MessageRouter {
     private registry;
     private config;
     private channels;
     private hooks?;
     private mesh?;
+    private serviceMatcher?;
+    private business?;
     private groupLog;
     private log;
+    /**
+     * Short-TTL cache of recently processed incoming message IDs, keyed by
+     * `<channel>:<accountId>:<id>`. Prevents duplicate replies from:
+     *   - GitLab webhook retries (same object_attributes.id redelivered)
+     *   - WhatsApp Baileys double-emitting messages.upsert (notify + append)
+     *   - Telegram polling re-delivering an update after a long-poll hiccup
+     *   - A daemon crash-loop replaying messages the previous process had
+     *     already handled (fixed by persisting this map to disk — see below)
+     *
+     * The key INCLUDES accountId so two bots in the same Telegram group
+     * (different accountId) both get to run their routing logic — the router's
+     * downstream boundAccount check then picks the one bot that should actually
+     * reply. Without accountId in the key, the second bot's legitimate view of
+     * the same Telegram message_id would be wrongly suppressed.
+     *
+     * Persisted to .agentx/router/dedup.json so survival-across-restart is not
+     * just a Telegram concern — the same universal LRU covers every channel.
+     * Writes are debounced (every 20 new ids, or 5s, whichever first) and the
+     * file is pruned to only live TTL entries before each write.
+     */
+    private recentMessageIds;
+    private readonly MESSAGE_ID_TTL_MS;
+    private readonly MESSAGE_ID_MAX_ENTRIES;
+    private readonly DEDUP_STORE_PATH;
+    private dedupDirtyCount;
+    private dedupSaveTimer?;
     constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
+    private loadDedupFromDisk;
+    private scheduleDedupSave;
+    private flushDedupToDisk;
+    /** Called by the daemon on graceful shutdown so no in-memory ids are lost. */
+    flushPersistence(): void;
     setMesh(mesh: A2AMesh): void;
+    setServiceMatcher(matcher: ServiceMatcher): void;
+    setBusiness(business: BusinessLayer): void;
     addChannel(adapter: ChannelAdapter): void;
     /**
      * Send an outbound message to any registered channel.
@@ -2793,6 +4382,11 @@ declare class MessageRouter {
     getChannelNames(): string[];
     startAll(): Promise<void>;
     stopAll(): Promise<void>;
+    /**
+     * Returns true if this message id was processed within MESSAGE_ID_TTL_MS.
+     * Stamps the key when false. Size-bounded GC avoids unbounded growth.
+     */
+    private isDuplicateMessage;
     private handleMessage;
     private static readonly MAX_BOT_CHAIN_DEPTH;
     /**
@@ -2812,6 +4406,16 @@ declare class MessageRouter {
      * Searches peer agent cards for mention matches.
      */
     private handleViaMesh;
+    /**
+     * Route to a mesh peer by resolved agentId (not text matching).
+     * Used when the channel adapter resolved the agent but it's not local.
+     */
+    private handleViaMeshByAgentId;
+    /**
+     * Route to a specific named mesh peer by agentId.
+     * Used when preferNode is set on the incoming message.
+     */
+    private handleViaMeshByPeer;
     private getAccountForAgent;
     private resolveAgent;
 }
@@ -2823,7 +4427,7 @@ interface TelegramAccountConfig {
 declare class TelegramAdapter implements ChannelAdapter {
     readonly name = "telegram";
     private accounts;
-    private offsets;
+    private offsetStore;
     private handler?;
     private polling;
     private log;
@@ -2926,7 +4530,12 @@ interface CronJobState {
     prompt: string;
     timeout: number;
     model?: string;
-    onError: "log" | "notify" | "disable";
+    /** Soft output-length cap appended to the prompt at invocation time.
+     *  Claude Code CLI has no hard flag for this, so we instruct the model
+     *  via the prompt tail; reliably honored and keeps cache-hit intact
+     *  (hint text is per-job, not per-run). */
+    maxOutputTokens?: number;
+    onError: Array<"log" | "notify" | "disable">;
     lastRun?: Date;
     nextRun?: Date;
     lastSuccess?: Date;