agentix-cli 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -1311,6 +1311,11 @@ declare const agentConfigSchema: z.ZodObject<{
         channel?: string | undefined;
         intervalMinutes?: number | undefined;
     }>>;
+    /** Reachability via the external public API.
+     *   - "private" (default): this agent is daemon-internal + channel-bound only.
+     *   - "public": external apps can POST /api/public/agents/<id>/messages
+     *     with a scoped token (agent:<id> or agent:*). */
+    access: z.ZodDefault<z.ZodEnum<["private", "public"]>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     workspace: string;
@@ -1326,6 +1331,7 @@ declare const agentConfigSchema: z.ZodObject<{
         channel: string;
         intervalMinutes: number;
     };
+    access: "private" | "public";
     provider?: string | undefined;
     model?: string | undefined;
     systemPrompt?: string | undefined;
@@ -1347,6 +1353,7 @@ declare const agentConfigSchema: z.ZodObject<{
         channel?: string | undefined;
         intervalMinutes?: number | undefined;
     } | undefined;
+    access?: "private" | "public" | undefined;
 }>;
 declare const cronJobSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1480,6 +1487,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             channel?: string | undefined;
             intervalMinutes?: number | undefined;
         }>>;
+        /** Reachability via the external public API.
+         *   - "private" (default): this agent is daemon-internal + channel-bound only.
+         *   - "public": external apps can POST /api/public/agents/<id>/messages
+         *     with a scoped token (agent:<id> or agent:*). */
+        access: z.ZodDefault<z.ZodEnum<["private", "public"]>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         workspace: string;
@@ -1495,6 +1507,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             channel: string;
             intervalMinutes: number;
         };
+        access: "private" | "public";
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
@@ -1516,6 +1529,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             channel?: string | undefined;
             intervalMinutes?: number | undefined;
         } | undefined;
+        access?: "private" | "public" | undefined;
     }>>>;
     channels: z.ZodDefault<z.ZodObject<{
         telegram: z.ZodDefault<z.ZodObject<{
@@ -1523,20 +1537,36 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
                 token: z.ZodString;
                 agentBinding: z.ZodString;
+                /** Per-account sender allowlist. When set, OVERRIDES the global
+                 *  `policy.allowFrom`. Entries accept:
+                 *    - numeric user id  ("1816212449")         — matches sender (from.id)
+                 *    - numeric chat id  ("-1003861455814")     — matches chat (chat.id)
+                 *    - "@username"                             — matches sender username
+                 *  A message is dispatched iff at least one entry matches. */
+                allowFrom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "strip", z.ZodTypeAny, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }>>>;
             policy: z.ZodDefault<z.ZodObject<{
                 dm: z.ZodDefault<z.ZodEnum<["pair", "block"]>>;
                 group: z.ZodDefault<z.ZodEnum<["mention-required", "all"]>>;
+                /** Global sender allowlist applied to every account that doesn't set
+                 *  its own `allowFrom`. When neither is configured, every incoming
+                 *  message is dropped — closed by default. Same entry forms as the
+                 *  per-account list (user id, chat id, @username). */
+                allowFrom: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "strip", z.ZodTypeAny, {
                 dm: "block" | "pair";
                 group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
             }, {
+                allowFrom?: string[] | undefined;
                 dm?: "block" | "pair" | undefined;
                 group?: "all" | "mention-required" | undefined;
             }>>;
@@ -1545,18 +1575,22 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }>;
             policy: {
                 dm: "block" | "pair";
                 group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
             };
         }, {
             enabled?: boolean | undefined;
             accounts?: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }> | undefined;
             policy?: {
+                allowFrom?: string[] | undefined;
                 dm?: "block" | "pair" | undefined;
                 group?: "all" | "mention-required" | undefined;
             } | undefined;
@@ -1587,13 +1621,13 @@ declare const daemonConfigSchema: z.ZodObject<{
                 group?: string | undefined;
                 contact?: string | undefined;
             }[];
-            defaultAgent?: string | undefined;
             allowFrom?: string[] | undefined;
+            defaultAgent?: string | undefined;
         }, {
             enabled?: boolean | undefined;
+            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
             defaultAgent?: string | undefined;
-            allowFrom?: string[] | undefined;
             routes?: {
                 agent: string;
                 group?: string | undefined;
@@ -1613,6 +1647,24 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         }>>;
+        slack: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** xoxb-... — bot user OAuth token from the Slack app's "OAuth & Permissions" tab. */
+            botToken: z.ZodOptional<z.ZodString>;
+            /** xapp-... — app-level token with connections:write scope (for Socket Mode). */
+            appToken: z.ZodOptional<z.ZodString>;
+            agentBinding: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        }>>;
         gitlab: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             webhookPort: z.ZodDefault<z.ZodNumber>;
@@ -1711,10 +1763,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }>;
             policy: {
                 dm: "block" | "pair";
                 group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
             };
         };
         whatsapp: {
@@ -1725,14 +1779,20 @@ declare const daemonConfigSchema: z.ZodObject<{
                 group?: string | undefined;
                 contact?: string | undefined;
             }[];
-            defaultAgent?: string | undefined;
             allowFrom?: string[] | undefined;
+            defaultAgent?: string | undefined;
         };
         discord: {
             enabled: boolean;
             token?: string | undefined;
             agentBinding?: string | undefined;
         };
+        slack: {
+            enabled: boolean;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        };
     }, {
         gitlab?: {
             enabled?: boolean | undefined;
@@ -1757,17 +1817,19 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts?: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }> | undefined;
             policy?: {
+                allowFrom?: string[] | undefined;
                 dm?: "block" | "pair" | undefined;
                 group?: "all" | "mention-required" | undefined;
             } | undefined;
         } | undefined;
         whatsapp?: {
             enabled?: boolean | undefined;
+            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
             defaultAgent?: string | undefined;
-            allowFrom?: string[] | undefined;
             routes?: {
                 agent: string;
                 group?: string | undefined;
@@ -1779,6 +1841,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         } | undefined;
+        slack?: {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        } | undefined;
     }>>;
     crons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -2359,18 +2427,27 @@ declare const daemonConfigSchema: z.ZodObject<{
         bind: z.ZodDefault<z.ZodString>;
         token: z.ZodOptional<z.ZodString>;
         daemonUrl: z.ZodDefault<z.ZodString>;
+        /** 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. */
         daemons: z.ZodDefault<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             url: z.ZodString;
+            dashboardUrl: z.ZodOptional<z.ZodString>;
             token: z.ZodOptional<z.ZodString>;
+            dashboardToken: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }, {
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }>, "many">>;
         draftAgent: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
@@ -2382,6 +2459,8 @@ declare const daemonConfigSchema: z.ZodObject<{
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }[];
         token?: string | undefined;
         draftAgent?: string | undefined;
@@ -2395,9 +2474,100 @@ declare const daemonConfigSchema: z.ZodObject<{
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }[] | undefined;
         draftAgent?: string | undefined;
     }>>;
+    graph: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Where the schema/nodes/classifications live. Relative to cwd. */
+        baseDir: z.ZodDefault<z.ZodString>;
+        /** Which agent makes LLM classification proposals. Falls back to
+         *  `dashboard.draftAgent` at call sites if unset. */
+        draftAgent: z.ZodOptional<z.ZodString>;
+        /** Agent used by `agentx graph review` to triage pending classifications.
+         *  Should be an agent with the wiki skill so it can call `wiki query` for
+         *  context before deciding approve/reject. Falls back to draftAgent. */
+        reviewAgent: z.ZodOptional<z.ZodString>;
+        /** Structural auto-approval policy. Evaluated against each classification
+         *  independently of `autoApproveConfidence`; either triggers approval.
+         *    - "strict"        : never approve via structure — every classification
+         *                        waits for human review
+         *    - "extend-leaves" : auto-approve when the proposed path (a) reuses only
+         *                        existing nodes, or (b) adds exactly one NEW node at
+         *                        the deepest level. Structural changes (new mid-path
+         *                        node, new root) still queue for review. Default.
+         *    - "any"           : auto-approve every classification regardless of
+         *                        structural change
+         */
+        autoApproveStructure: z.ZodDefault<z.ZodEnum<["strict", "extend-leaves", "any"]>>;
+        /** Minimum classifier confidence (0..1) to auto-approve. OR'd with the
+         *  structural policy — either hitting the threshold lets the classification
+         *  bypass the pending queue. 1.0 (default) disables this knob, so approval
+         *  is driven by `autoApproveStructure` alone. Lower it to e.g. 0.7 if you
+         *  also want high-confidence structural changes auto-approved. */
+        autoApproveConfidence: z.ZodDefault<z.ZodNumber>;
+        /** Weights for the wiki hybrid retrieval score. Path-ancestry match vs
+         *  BM25 over article text. Sum need not be 1. */
+        retrievalWeights: z.ZodDefault<z.ZodObject<{
+            graph: z.ZodDefault<z.ZodNumber>;
+            bm25: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            graph: number;
+            bm25: number;
+        }, {
+            graph?: number | undefined;
+            bm25?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        baseDir: string;
+        autoApproveStructure: "any" | "strict" | "extend-leaves";
+        autoApproveConfidence: number;
+        retrievalWeights: {
+            graph: number;
+            bm25: number;
+        };
+        draftAgent?: string | undefined;
+        reviewAgent?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        draftAgent?: string | undefined;
+        baseDir?: string | undefined;
+        reviewAgent?: string | undefined;
+        autoApproveStructure?: "any" | "strict" | "extend-leaves" | undefined;
+        autoApproveConfidence?: number | undefined;
+        retrievalWeights?: {
+            graph?: number | undefined;
+            bm25?: number | undefined;
+        } | undefined;
+    }>>;
+    /** Registered inbound webhooks — an inventory the dashboard manages. Each
+     *  entry binds an (agent, source) pair to an optional signing secret. The
+     *  actual inbound URL is always POST /webhook/<agentId>/<source>. */
+    webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<["gitlab", "github", "sentry", "stripe", "discord", "slack", "custom"]>;
+        agentId: z.ZodString;
+        secretEnv: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        id: string;
+        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        agentId: string;
+        description?: string | undefined;
+        secretEnv?: string | undefined;
+    }, {
+        id: string;
+        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        agentId: string;
+        enabled?: boolean | undefined;
+        description?: string | undefined;
+        secretEnv?: string | undefined;
+    }>, "many">>;
     /** 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
@@ -2425,6 +2595,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             channel: string;
             intervalMinutes: number;
         };
+        access: "private" | "public";
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
@@ -2448,6 +2619,18 @@ declare const daemonConfigSchema: z.ZodObject<{
         bind: string;
         defaultAgent?: string | undefined;
     };
+    graph: {
+        enabled: boolean;
+        baseDir: string;
+        autoApproveStructure: "any" | "strict" | "extend-leaves";
+        autoApproveConfidence: number;
+        retrievalWeights: {
+            graph: number;
+            bm25: number;
+        };
+        draftAgent?: string | undefined;
+        reviewAgent?: string | undefined;
+    };
     providers: Record<string, {
         apiKey?: string | undefined;
         defaultModel?: string | undefined;
@@ -2477,10 +2660,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }>;
             policy: {
                 dm: "block" | "pair";
                 group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
             };
         };
         whatsapp: {
@@ -2491,14 +2676,20 @@ declare const daemonConfigSchema: z.ZodObject<{
                 group?: string | undefined;
                 contact?: string | undefined;
             }[];
-            defaultAgent?: string | undefined;
             allowFrom?: string[] | undefined;
+            defaultAgent?: string | undefined;
         };
         discord: {
             enabled: boolean;
             token?: string | undefined;
             agentBinding?: string | undefined;
         };
+        slack: {
+            enabled: boolean;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        };
     };
     crons: Record<string, {
         enabled: boolean;
@@ -2587,10 +2778,20 @@ declare const daemonConfigSchema: z.ZodObject<{
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }[];
         token?: string | undefined;
         draftAgent?: string | undefined;
     };
+    webhooks: {
+        enabled: boolean;
+        id: string;
+        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        agentId: string;
+        description?: string | undefined;
+        secretEnv?: string | undefined;
+    }[];
     session: {
         staleMinutes: number;
     };
@@ -2661,6 +2862,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             channel?: string | undefined;
             intervalMinutes?: number | undefined;
         } | undefined;
+        access?: "private" | "public" | undefined;
     }> | undefined;
     mesh?: {
         enabled?: boolean | undefined;
@@ -2675,6 +2877,18 @@ declare const daemonConfigSchema: z.ZodObject<{
             interval?: number | undefined;
         } | undefined;
     } | undefined;
+    graph?: {
+        enabled?: boolean | undefined;
+        draftAgent?: string | undefined;
+        baseDir?: string | undefined;
+        reviewAgent?: string | undefined;
+        autoApproveStructure?: "any" | "strict" | "extend-leaves" | undefined;
+        autoApproveConfidence?: number | undefined;
+        retrievalWeights?: {
+            graph?: number | undefined;
+            bm25?: number | undefined;
+        } | undefined;
+    } | undefined;
     providers?: Record<string, {
         apiKey?: string | undefined;
         defaultModel?: string | undefined;
@@ -2704,17 +2918,19 @@ declare const daemonConfigSchema: z.ZodObject<{
             accounts?: Record<string, {
                 token: string;
                 agentBinding: string;
+                allowFrom?: string[] | undefined;
             }> | undefined;
             policy?: {
+                allowFrom?: string[] | undefined;
                 dm?: "block" | "pair" | undefined;
                 group?: "all" | "mention-required" | undefined;
             } | undefined;
         } | undefined;
         whatsapp?: {
             enabled?: boolean | undefined;
+            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
             defaultAgent?: string | undefined;
-            allowFrom?: string[] | undefined;
             routes?: {
                 agent: string;
                 group?: string | undefined;
@@ -2726,6 +2942,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             agentBinding?: string | undefined;
         } | undefined;
+        slack?: {
+            enabled?: boolean | undefined;
+            agentBinding?: string | undefined;
+            botToken?: string | undefined;
+            appToken?: string | undefined;
+        } | undefined;
     } | undefined;
     crons?: Record<string, {
         agent: string;
@@ -2857,9 +3079,19 @@ declare const daemonConfigSchema: z.ZodObject<{
             name: string;
             url: string;
             token?: string | undefined;
+            dashboardUrl?: string | undefined;
+            dashboardToken?: string | undefined;
         }[] | undefined;
         draftAgent?: string | undefined;
     } | undefined;
+    webhooks?: {
+        id: string;
+        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        agentId: string;
+        enabled?: boolean | undefined;
+        description?: string | undefined;
+        secretEnv?: string | undefined;
+    }[] | undefined;
     session?: {
         staleMinutes?: number | undefined;
     } | undefined;
@@ -2974,6 +3206,12 @@ declare class AgentXDaemon {
      * GET /events — streams daemon logs in real-time.
      */
     private handleSSE;
+    /**
+     * Stream a single running task's live output as SSE.
+     * Sends a `start` event with the existing buffer (so a late opener catches up),
+     * then `chunk` events for every new delta, and `end` when the task finishes.
+     */
+    private handleTaskStream;
     private handleHttp;
     /**
      * OpenAI-compatible chat completions endpoint.
@@ -3245,14 +3483,27 @@ declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?:
  */
 declare function executeTask(agent: AgentDef, task: AgentTask, providers: Record<string, {
     apiKey?: string;
-}>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string): Promise<AgentResponse>;
+}>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void): Promise<AgentResponse>;
 
 type WikiAccess = "private" | "shared" | "public";
 /**
- * Article metadata. Intentionally minimal — tags do the heavy lifting.
+ * Article type — the organizational spine. Matches Farzapedia's
+ * `type: person | project | place | concept | event`, extended with
+ * `decision` and `pattern` for workflow-heavy corpora.
+ * Optional on legacy articles; Phase 2 migration backfills it.
+ */
+type WikiArticleType = "person" | "project" | "place" | "concept" | "event" | "decision" | "pattern";
+/**
+ * Article metadata. `type` + `related` are the primary retrieval surface;
+ * tags remain as a secondary hint but are no longer central.
  */
 interface WikiArticleMeta {
     title: string;
+    /** Organizational spine — Phase 2 migration backfills any missing values. */
+    type?: WikiArticleType;
+    /** Wikilink targets (by title) — persisted from `[[wikilinks]]` in body. */
+    related?: string[];
+    /** Secondary hint, no longer the retrieval spine. */
     tags: string[];
     owner: string;
     access: WikiAccess;
@@ -3260,6 +3511,10 @@ interface WikiArticleMeta {
     created: string;
     lastUpdated: string;
     sources: string[];
+    /** Intent graph path (root → leaf node ids) when the article was authored
+     *  under an active intent graph. Empty for legacy articles — retrieval
+     *  falls back to pure BM25 for those. */
+    graphPath?: string[];
 }
 interface WikiArticle {
     meta: WikiArticleMeta;
@@ -3279,6 +3534,8 @@ interface WikiIndex {
     articles: Array<{
         path: string;
         title: string;
+        type?: WikiArticleType;
+        related?: string[];
         tags: string[];
         owner: string;
         access: WikiAccess;
@@ -3292,7 +3549,7 @@ interface WikiIndex {
 }
 
 declare class WikiStore {
-    private baseDir;
+    readonly baseDir: string;
     private rawDir;
     private log;
     constructor(baseDir?: string, log?: (...args: unknown[]) => void);
@@ -3356,9 +3613,19 @@ declare class WikiStore {
     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.
+     *
+     * Scoring:
+     *   - BM25 over title+tags+content (always)
+     *   - + ancestry bonus if the caller classified the message through the
+     *     intent graph and articles carry `graphPath` from a previous classification
+     *
+     * `weights.graph` is scaled against `weights.bm25`. When the caller omits
+     * `messagePath`, retrieval collapses to pure BM25 and matches legacy behavior.
      */
-    findRelevant(message: string, agentId?: string, maxArticles?: number): WikiArticle[];
+    findRelevant(message: string, agentId?: string, maxArticles?: number, messagePath?: string[], weights?: {
+        graph: number;
+        bm25: number;
+    }): WikiArticle[];
     /**
      * Build context string from relevant wiki articles for prompt injection.
      * Token-efficient: includes title + first ~500 chars of each article.
@@ -3368,6 +3635,15 @@ declare class WikiStore {
      * Rebuild the master index.
      */
     rebuildIndex(): WikiIndex;
+    /**
+     * Write `_index.md` — the Farzapedia-style content catalog grouped by
+     * article `type`. This is the one file the agentic query (Phase 3) reads
+     * to pick candidate articles before walking the wikilink subgraph.
+     *
+     * Articles without a `type` land in "Untyped" at the bottom; the Phase 2
+     * migration backfills those.
+     */
+    private writeCatalog;
     /**
      * Get wiki stats.
      */
@@ -3555,6 +3831,25 @@ interface RunningTask {
     /** Wall-clock start. */
     startedAt: Date;
 }
+type TaskOutputSubscriber = (chunk: string) => void;
+/** Persisted record of a finished task, written to .agentx/task-history. */
+interface TaskRecord {
+    id: string;
+    agentId: string;
+    channel: string;
+    chatId?: string;
+    sender?: string;
+    message: string;
+    startedAt: string;
+    endedAt: string;
+    durationMs: number;
+    ok: boolean;
+    error?: string;
+    /** Final agent text (one-shot, may be empty if streaming captured it). */
+    responseText: string;
+    /** Terminal-style transcript captured from stream-json events. */
+    transcript: string;
+}
 declare class AgentRegistry {
     private agents;
     private config;
@@ -3567,14 +3862,31 @@ declare class AgentRegistry {
     private tokenTracker;
     private landscape?;
     private messageQueue;
+    /** Intent Knowledge Graph classifier. Null when graph.enabled=false. */
+    private classifier?;
+    private graphStore?;
+    /** Runtime handover store — shared with MessageRouter via file on disk. */
+    private handoverStore;
     /** Active soul profile per agent+chat session: "agentId:channel:chatId" → profile name */
     private activeSouls;
+    /** Live output captured per running task id — drives the dashboard streaming modal. */
+    private taskOutputs;
+    /** Last completed task summary per agent — single-line blurb for the dashboard card. */
+    private lastSummaries;
+    /** 24-hour sparkline cache per agent — recomputed from disk at most once a minute. */
+    private sparklineCache;
     private log;
     constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
     /**
      * Set landscape builder (called after mesh init).
      */
     setLandscape(builder: LandscapeBuilder): void;
+    /**
+     * If there's an active handover routing TO this agent for this (channel,
+     * chatId) pair AND the operator's summary hasn't been consumed yet, pull
+     * + clear it so the target agent sees the note exactly once.
+     */
+    private buildHandoverNote;
     /**
      * Get agent definition by ID.
      */
@@ -3625,7 +3937,57 @@ declare class AgentRegistry {
         errors: number;
         lastActive?: Date;
         runningTasks: RunningTask[];
+        lastSummary?: {
+            text: string;
+            at: string;
+            ok: boolean;
+        };
+        hourlyTasks?: number[];
     }>;
+    /**
+     * Write a finished task record to disk under .agentx/task-history/<agent>/<yyyy-mm-dd>/.
+     * Side-effects only — call sites should treat failure as best-effort.
+     */
+    private persistTaskRecord;
+    /**
+     * Compute a 24-hour hourly task-count sparkline for an agent from persisted
+     * history. Returns an array of 24 numbers: buckets[0] = 23-24h ago,
+     * buckets[23] = now-hour. Cached per-agent for 60s to keep snapshot load
+     * reasonable when the dashboard polls every 2s.
+     */
+    getHourlySparkline(agentId: string, hours?: number): number[];
+    /**
+     * Rebuild the in-memory lastSummaries cache from disk so dashboard cards
+     * show the most recent "what did they do" line even right after a restart.
+     * Called once on daemon startup — one file read per agent.
+     */
+    hydrateLastSummariesFromDisk(): number;
+    /**
+     * Drop history folders older than retention window. Cheap startup-time
+     * sweep — once a day is plenty, but doing it on every daemon boot is fine.
+     */
+    pruneTaskHistory(retentionDays?: number): number;
+    /**
+     * Newest-first list of task records for one agent, capped at `limit`.
+     * Walks at most the last few day folders so this is O(limit), not O(history).
+     */
+    listTaskHistory(agentId: string, limit?: number): Array<Omit<TaskRecord, "transcript" | "responseText">>;
+    /**
+     * Look up one task's full record (transcript included) across the retention window.
+     */
+    getTaskRecord(agentId: string, taskId: string): TaskRecord | null;
+    private safe;
+    /**
+     * Subscribe to live output for a running task. Returns the buffer that has
+     * accumulated so far plus an unsubscribe handle. If the task is unknown,
+     * returns null. If the task already finished, the subscriber is given the
+     * tail buffer and immediately ended.
+     */
+    subscribeToTaskOutput(taskId: string, sub: TaskOutputSubscriber): {
+        initial: string;
+        done: boolean;
+        unsubscribe: () => void;
+    } | null;
     /**
      * Get token usage summary.
      */
@@ -3751,6 +4113,58 @@ interface ChannelAdapter {
     getChannelMeta?(chatId: string): Promise<ChannelMeta | undefined>;
 }
 
+interface HandoverOverride {
+    channel: string;
+    chatId: string;
+    accountId?: string;
+    fromAgent: string;
+    toAgent: string;
+    summary?: string;
+    createdAt: string;
+    createdBy?: string;
+    /** When set, overrides past this time are treated as expired (ignored on
+     *  read, optionally pruned on access). null = indefinite. */
+    expiresAt?: string | null;
+    /** Set after the summary has been injected once. Route stays active. */
+    summaryConsumedAt?: string;
+}
+interface HandoverFile {
+    version: number;
+    overrides: Record<string, HandoverOverride>;
+}
+declare class HandoverStore {
+    readonly filePath: string;
+    private log;
+    constructor(opts?: {
+        baseDir?: string;
+        log?: (...args: unknown[]) => void;
+    });
+    /** Canonical key for an override. Using "-" for missing accountId keeps
+     *  the key shape uniform across channels. */
+    key(channel: string, chatId: string, accountId?: string): string;
+    load(): HandoverFile;
+    private save;
+    /** Return the active override for a chat, or undefined. Skips expired. */
+    get(channel: string, chatId: string, accountId?: string): HandoverOverride | undefined;
+    /** Create or replace an override. If `fromAgent` isn't supplied the caller
+     *  can pass "" and the router will fill it in from current routing. */
+    set(o: Omit<HandoverOverride, "createdAt"> & {
+        createdAt?: string;
+    }): HandoverOverride;
+    /** Remove an override (release the handover). Idempotent. */
+    remove(channel: string, chatId: string, accountId?: string): boolean;
+    /** Mark the summary as consumed (after it's been injected once). Route
+     *  stays active; subsequent messages just skip the note. */
+    consumeSummary(channel: string, chatId: string, accountId?: string): string | undefined;
+    /** List all non-expired overrides. Used by the admin UI. */
+    listActive(): HandoverOverride[];
+    /** Overrides pointing at this agent (incoming) or away from it (outgoing). */
+    listByAgent(agentId: string): {
+        incoming: HandoverOverride[];
+        outgoing: HandoverOverride[];
+    };
+}
+
 interface ServiceTrigger {
     pattern: string;
     channel?: string;
@@ -4332,7 +4746,13 @@ declare class MessageRouter {
     private serviceMatcher?;
     private business?;
     private groupLog;
+    /** Runtime per-chat routing overrides (handovers). Consulted at the top
+     *  of resolveAgent; config routes + mention matching only run when no
+     *  override applies. */
+    private handoverStore;
     private log;
+    /** Exposed so the admin panel + registry can share the same store. */
+    getHandoverStore(): HandoverStore;
     /**
      * Short-TTL cache of recently processed incoming message IDs, keyed by
      * `<channel>:<accountId>:<id>`. Prevents duplicate replies from:
@@ -4359,6 +4779,8 @@ declare class MessageRouter {
     private readonly DEDUP_STORE_PATH;
     private dedupDirtyCount;
     private dedupSaveTimer?;
+    /** Crash-safe inflight log (see InflightLog class above). */
+    private inflight;
     constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
     private loadDedupFromDisk;
     private scheduleDedupSave;
@@ -4381,6 +4803,12 @@ declare class MessageRouter {
     /** List registered channel names. */
     getChannelNames(): string[];
     startAll(): Promise<void>;
+    /**
+     * On startup, re-run any incoming message that was recorded as `start` but
+     * never got a matching `done` in the inflight log. Those are tasks the
+     * previous process committed to handling but crashed before completing.
+     */
+    private replayInflight;
     stopAll(): Promise<void>;
     /**
      * Returns true if this message id was processed within MESSAGE_ID_TTL_MS.
@@ -4388,6 +4816,9 @@ declare class MessageRouter {
      */
     private isDuplicateMessage;
     private handleMessage;
+    /** The actual processing body — split out so handleMessage can wrap it in
+     *  the inflight try/finally without drowning the happy path in indentation. */
+    private processResolvedMessage;
     private static readonly MAX_BOT_CHAIN_DEPTH;
     /**
      * Bot-to-bot conversation chain.
@@ -4423,6 +4854,7 @@ declare class MessageRouter {
 interface TelegramAccountConfig {
     token: string;
     agentBinding: string;
+    allowFrom?: string[];
 }
 declare class TelegramAdapter implements ChannelAdapter {
     readonly name = "telegram";
@@ -4431,7 +4863,22 @@ declare class TelegramAdapter implements ChannelAdapter {
     private handler?;
     private polling;
     private log;
-    constructor(accounts: Record<string, TelegramAccountConfig>, log?: (...args: unknown[]) => void);
+    /** Global allowlist fallback. When a per-account allowFrom is unset,
+     *  this list applies. When BOTH are unset, everything is rejected
+     *  (closed by default). */
+    private globalAllowFrom?;
+    constructor(accounts: Record<string, TelegramAccountConfig>, opts?: {
+        policy?: {
+            allowFrom?: string[];
+        };
+    }, log?: (...args: unknown[]) => void);
+    /** Effective sender allowlist for an account. Returns undefined when the
+     *  account has no explicit config AND the global policy is unset — the
+     *  caller treats undefined as "closed, drop everything". */
+    private effectiveAllowFrom;
+    /** Accept a message only when at least one allowlist entry matches the
+     *  sender's user id, the chat id, or the sender's @username. */
+    private isAllowed;
     onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -4502,11 +4949,18 @@ declare class WhatsAppAdapter implements ChannelAdapter {
     private generation;
     private sentMessageIds;
     private log;
+    /** Fires whenever the underlying WhatsApp socket emits a new QR or clears it.
+     *  Passing null means the session is now connected. */
+    private onQR?;
+    /** Fires whenever the connection state changes (connecting / open / close). */
+    private onStatus?;
     constructor(config: {
         sessionDir: string;
         defaultAgent?: string;
         allowFrom?: string[];
         routes?: WhatsAppRoute[];
+        onQR?: (qr: string | null) => void;
+        onStatus?: (status: "connecting" | "open" | "close", detail?: string) => void;
     }, log?: (...args: unknown[]) => void);
     /**
      * Resolve which agent handles a message based on routes.
@@ -4617,6 +5071,606 @@ declare class CronScheduler {
     };
 }
 
+declare const axisTypeSchema: z.ZodEnum<["enum", "free", "ref"]>;
+type AxisType = z.infer<typeof axisTypeSchema>;
+declare const axisDefSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["enum", "free", "ref"]>;
+    /** For type="enum": closed set of allowed values. */
+    values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** For type="ref": which level's nodes may be referenced. */
+    refLevel: z.ZodOptional<z.ZodString>;
+    /** If true, this axis may be absent from a node without failing validation.
+     *  Use for axes that apply conditionally (e.g. a department's "lead" ref
+     *  doesn't apply to a person-kind unit). Absent/false = required. */
+    optional: z.ZodOptional<z.ZodBoolean>;
+    /** Optional human-readable help, shown as tooltip in the admin UI. */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "enum" | "free" | "ref";
+    name: string;
+    values?: string[] | undefined;
+    description?: string | undefined;
+    refLevel?: string | undefined;
+    optional?: boolean | undefined;
+}, {
+    type: "enum" | "free" | "ref";
+    name: string;
+    values?: string[] | undefined;
+    description?: string | undefined;
+    refLevel?: string | undefined;
+    optional?: boolean | undefined;
+}>;
+type AxisDef = z.infer<typeof axisDefSchema>;
+declare const levelDefSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** Axes every node at this level MUST carry. Order matters for UI rendering. */
+    axes: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["enum", "free", "ref"]>;
+        /** For type="enum": closed set of allowed values. */
+        values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** For type="ref": which level's nodes may be referenced. */
+        refLevel: z.ZodOptional<z.ZodString>;
+        /** If true, this axis may be absent from a node without failing validation.
+         *  Use for axes that apply conditionally (e.g. a department's "lead" ref
+         *  doesn't apply to a person-kind unit). Absent/false = required. */
+        optional: z.ZodOptional<z.ZodBoolean>;
+        /** Optional human-readable help, shown as tooltip in the admin UI. */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }>, "many">;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    axes: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }[];
+    description?: string | undefined;
+}, {
+    id: string;
+    axes: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }[];
+    description?: string | undefined;
+}>;
+type LevelDef = z.infer<typeof levelDefSchema>;
+declare const graphSchemaSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    /** Ordered from root to leaf. Max 5 to keep the taxonomy scannable. */
+    levels: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Axes every node at this level MUST carry. Order matters for UI rendering. */
+        axes: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["enum", "free", "ref"]>;
+            /** For type="enum": closed set of allowed values. */
+            values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            /** For type="ref": which level's nodes may be referenced. */
+            refLevel: z.ZodOptional<z.ZodString>;
+            /** If true, this axis may be absent from a node without failing validation.
+             *  Use for axes that apply conditionally (e.g. a department's "lead" ref
+             *  doesn't apply to a person-kind unit). Absent/false = required. */
+            optional: z.ZodOptional<z.ZodBoolean>;
+            /** Optional human-readable help, shown as tooltip in the admin UI. */
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }, {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }>, "many">;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        axes: {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }[];
+        description?: string | undefined;
+    }, {
+        id: string;
+        axes: {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }[];
+        description?: string | undefined;
+    }>, "many">;
+    /** Axis describing where a leaf classification came from (channel, cron, etc.). */
+    leafInput: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["enum", "free", "ref"]>;
+        /** For type="enum": closed set of allowed values. */
+        values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** For type="ref": which level's nodes may be referenced. */
+        refLevel: z.ZodOptional<z.ZodString>;
+        /** If true, this axis may be absent from a node without failing validation.
+         *  Use for axes that apply conditionally (e.g. a department's "lead" ref
+         *  doesn't apply to a person-kind unit). Absent/false = required. */
+        optional: z.ZodOptional<z.ZodBoolean>;
+        /** Optional human-readable help, shown as tooltip in the admin UI. */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }>>;
+    /** Free-form description of the expected result of a leaf classification. */
+    leafOutput: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["enum", "free", "ref"]>;
+        /** For type="enum": closed set of allowed values. */
+        values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** For type="ref": which level's nodes may be referenced. */
+        refLevel: z.ZodOptional<z.ZodString>;
+        /** If true, this axis may be absent from a node without failing validation.
+         *  Use for axes that apply conditionally (e.g. a department's "lead" ref
+         *  doesn't apply to a person-kind unit). Absent/false = required. */
+        optional: z.ZodOptional<z.ZodBoolean>;
+        /** Optional human-readable help, shown as tooltip in the admin UI. */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }, {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    levels: {
+        id: string;
+        axes: {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }[];
+        description?: string | undefined;
+    }[];
+    leafInput?: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    leafOutput?: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+}, {
+    levels: {
+        id: string;
+        axes: {
+            type: "enum" | "free" | "ref";
+            name: string;
+            values?: string[] | undefined;
+            description?: string | undefined;
+            refLevel?: string | undefined;
+            optional?: boolean | undefined;
+        }[];
+        description?: string | undefined;
+    }[];
+    version?: number | undefined;
+    leafInput?: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+    leafOutput?: {
+        type: "enum" | "free" | "ref";
+        name: string;
+        values?: string[] | undefined;
+        description?: string | undefined;
+        refLevel?: string | undefined;
+        optional?: boolean | undefined;
+    } | undefined;
+}>;
+type GraphSchema = z.infer<typeof graphSchemaSchema>;
+declare const graphNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** Matches a `levels[*].id` from the schema. */
+    level: z.ZodString;
+    /** null for root-level nodes (level[0]); otherwise the id of a node at level-1. */
+    parentId: z.ZodNullable<z.ZodString>;
+    /** Values for every axis declared at this level's schema entry. `ref` axes
+     *  hold the id of another node; `enum` axes hold one of the declared values;
+     *  `free` axes hold any string. */
+    axes: z.ZodRecord<z.ZodString, z.ZodString>;
+    createdAt: z.ZodString;
+    createdBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    createdAt: string;
+    axes: Record<string, string>;
+    level: string;
+    parentId: string | null;
+    createdBy?: string | undefined;
+}, {
+    id: string;
+    createdAt: string;
+    axes: Record<string, string>;
+    level: string;
+    parentId: string | null;
+    createdBy?: string | undefined;
+}>;
+type GraphNode = z.infer<typeof graphNodeSchema>;
+declare const classificationSourceSchema: z.ZodEnum<["llm", "user", "cache"]>;
+type ClassificationSource = z.infer<typeof classificationSourceSchema>;
+declare const classificationStatusSchema: z.ZodEnum<["pending", "approved", "rejected"]>;
+type ClassificationStatus = z.infer<typeof classificationStatusSchema>;
+declare const classificationSchema: z.ZodObject<{
+    ts: z.ZodString;
+    msgHash: z.ZodString;
+    agentId: z.ZodOptional<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    sender: z.ZodOptional<z.ZodString>;
+    /** Node ids from root to leaf, one per level. Shorter-than-full paths are
+     *  allowed if the classifier was only confident down to a certain depth. */
+    path: z.ZodArray<z.ZodString, "many">;
+    /** Axis values asserted by the classifier for new nodes it proposed along
+     *  the path. Keyed by node id. */
+    proposedAxes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    /** Leaf-level extras. */
+    leaf: z.ZodDefault<z.ZodObject<{
+        input: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        output: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        output?: string | undefined;
+        input?: string | undefined;
+    }, {
+        output?: string | undefined;
+        input?: string | undefined;
+    }>>;
+    source: z.ZodEnum<["llm", "user", "cache"]>;
+    status: z.ZodEnum<["pending", "approved", "rejected"]>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    /** Redacted first ~200 chars of the message, for the approval UI. */
+    preview: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string[];
+    status: "pending" | "approved" | "rejected";
+    source: "user" | "llm" | "cache";
+    ts: string;
+    msgHash: string;
+    proposedAxes: Record<string, Record<string, string>>;
+    leaf: {
+        output?: string | undefined;
+        input?: string | undefined;
+    };
+    channel?: string | undefined;
+    agentId?: string | undefined;
+    sender?: string | undefined;
+    confidence?: number | undefined;
+    preview?: string | undefined;
+}, {
+    path: string[];
+    status: "pending" | "approved" | "rejected";
+    source: "user" | "llm" | "cache";
+    ts: string;
+    msgHash: string;
+    channel?: string | undefined;
+    agentId?: string | undefined;
+    sender?: string | undefined;
+    proposedAxes?: Record<string, Record<string, string>> | undefined;
+    leaf?: {
+        output?: string | undefined;
+        input?: string | undefined;
+    } | undefined;
+    confidence?: number | undefined;
+    preview?: string | undefined;
+}>;
+type Classification = z.infer<typeof classificationSchema>;
+/** Row in the fingerprint → path snap cache. */
+declare const fingerprintEntrySchema: z.ZodObject<{
+    fingerprint: z.ZodString;
+    path: z.ZodArray<z.ZodString, "many">;
+    leaf: z.ZodDefault<z.ZodObject<{
+        input: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        output: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        output?: string | undefined;
+        input?: string | undefined;
+    }, {
+        output?: string | undefined;
+        input?: string | undefined;
+    }>>;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string[];
+    leaf: {
+        output?: string | undefined;
+        input?: string | undefined;
+    };
+    fingerprint: string;
+    updatedAt: string;
+}, {
+    path: string[];
+    fingerprint: string;
+    updatedAt: string;
+    leaf?: {
+        output?: string | undefined;
+        input?: string | undefined;
+    } | undefined;
+}>;
+type FingerprintEntry = z.infer<typeof fingerprintEntrySchema>;
+/** Nodes file is a plain list, not a nested tree — lookups are by id. */
+declare const nodesFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** Matches a `levels[*].id` from the schema. */
+        level: z.ZodString;
+        /** null for root-level nodes (level[0]); otherwise the id of a node at level-1. */
+        parentId: z.ZodNullable<z.ZodString>;
+        /** Values for every axis declared at this level's schema entry. `ref` axes
+         *  hold the id of another node; `enum` axes hold one of the declared values;
+         *  `free` axes hold any string. */
+        axes: z.ZodRecord<z.ZodString, z.ZodString>;
+        createdAt: z.ZodString;
+        createdBy: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        createdAt: string;
+        axes: Record<string, string>;
+        level: string;
+        parentId: string | null;
+        createdBy?: string | undefined;
+    }, {
+        id: string;
+        createdAt: string;
+        axes: Record<string, string>;
+        level: string;
+        parentId: string | null;
+        createdBy?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    nodes: {
+        id: string;
+        createdAt: string;
+        axes: Record<string, string>;
+        level: string;
+        parentId: string | null;
+        createdBy?: string | undefined;
+    }[];
+}, {
+    version?: number | undefined;
+    nodes?: {
+        id: string;
+        createdAt: string;
+        axes: Record<string, string>;
+        level: string;
+        parentId: string | null;
+        createdBy?: string | undefined;
+    }[] | undefined;
+}>;
+type NodesFile = z.infer<typeof nodesFileSchema>;
+/** Index file — record of fingerprints. Hot path; kept as a map on disk. */
+declare const indexFileSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodNumber>;
+    entries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fingerprint: z.ZodString;
+        path: z.ZodArray<z.ZodString, "many">;
+        leaf: z.ZodDefault<z.ZodObject<{
+            input: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            output: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            output?: string | undefined;
+            input?: string | undefined;
+        }, {
+            output?: string | undefined;
+            input?: string | undefined;
+        }>>;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string[];
+        leaf: {
+            output?: string | undefined;
+            input?: string | undefined;
+        };
+        fingerprint: string;
+        updatedAt: string;
+    }, {
+        path: string[];
+        fingerprint: string;
+        updatedAt: string;
+        leaf?: {
+            output?: string | undefined;
+            input?: string | undefined;
+        } | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    entries: Record<string, {
+        path: string[];
+        leaf: {
+            output?: string | undefined;
+            input?: string | undefined;
+        };
+        fingerprint: string;
+        updatedAt: string;
+    }>;
+    version: number;
+}, {
+    entries?: Record<string, {
+        path: string[];
+        fingerprint: string;
+        updatedAt: string;
+        leaf?: {
+            output?: string | undefined;
+            input?: string | undefined;
+        } | undefined;
+    }> | undefined;
+    version?: number | undefined;
+}>;
+type IndexFile = z.infer<typeof indexFileSchema>;
+
+/**
+ * Ships with the install. When .agentx/graph/schema.json is missing, the
+ * store seeds this so a fresh daemon has something to classify against.
+ *
+ * Five levels, three primaries at the leaf (who / what / where) — matches
+ * the "primary colors per level" design from the plan.
+ */
+declare const STARTER_SCHEMA: GraphSchema;
+
+interface GraphStoreOptions {
+    baseDir?: string;
+    log?: (...args: unknown[]) => void;
+}
+declare class GraphStore {
+    readonly baseDir: string;
+    private log;
+    constructor(opts?: GraphStoreOptions);
+    schemaPath(): string;
+    nodesPath(): string;
+    indexPath(): string;
+    classificationsPath(): string;
+    /** Load the graph schema, seeding STARTER_SCHEMA if the file is missing. */
+    loadSchema(): GraphSchema;
+    saveSchema(schema: GraphSchema): void;
+    loadNodes(): NodesFile;
+    saveNodes(file: NodesFile): void;
+    /** Validate a node against the schema AND uniqueness within the nodes file. */
+    validateNode(node: GraphNode, schema: GraphSchema, all: GraphNode[]): void;
+    /**
+     * Commit a full classification path: for each path element that doesn't
+     * yet exist, infer its schema level by matching the proposed axes against
+     * the level's required axes (first match ≥ cursor wins — this handles
+     * paths that skip levels, like business → noqta where location is
+     * absent). Refreshes the node list between adds so callers in a loop
+     * don't hit "Node id already exists" on the second iteration.
+     */
+    commitNodesAlongPath(path: string[], proposedAxes: Record<string, Record<string, string>>, schema: GraphSchema, createdBy?: string): {
+        added: GraphNode[];
+        skipped: string[];
+    };
+    /** Append a node. Caller is responsible for id uniqueness; we check and throw. */
+    addNode(node: GraphNode): GraphNode;
+    appendClassification(c: Classification): boolean;
+    /**
+     * All pending classifications, newest first. Collapses the append-only
+     * ledger by msgHash — the most recent entry per message wins (so if an
+     * entry was updated via updateClassificationStatus, we see the current
+     * state, not the original).
+     */
+    listPendingClassifications(limit?: number): Classification[];
+    /** Same contract as listPendingClassifications but filtered to any status. */
+    listByStatus(status: Classification["status"], limit?: number): Classification[];
+    /**
+     * Read every classification, collapse by msgHash keeping the newest entry
+     * per message. Used by listByStatus + the review loop to see current state.
+     * Returns newest-first order.
+     */
+    private readAllCollapsed;
+    /**
+     * Append a status-update entry for an existing classification. The ledger
+     * stays append-only; readers collapse by msgHash. Returns the updated
+     * classification, or null if no prior entry for msgHash exists.
+     */
+    updateClassificationStatus(msgHash: string, update: {
+        status: Classification["status"];
+        reviewer?: string;
+        reviewReason?: string;
+    }): Classification | null;
+    /** Read the last N classifications, newest first. Cheap enough for the admin UI. */
+    readRecentClassifications(limit?: number): Classification[];
+    /**
+     * Hash that represents "this kind of message" for snap-to-path caching.
+     * Normalizes casing + whitespace; includes channel + sender so two people
+     * writing the same words can still land on different paths if they should.
+     */
+    fingerprint(msg: {
+        text: string;
+        channel?: string;
+        sender?: string;
+    }): string;
+    loadIndex(): IndexFile;
+    saveIndex(file: IndexFile): void;
+    getFingerprint(fp: string): FingerprintEntry | undefined;
+    setFingerprint(fp: string, entry: Omit<FingerprintEntry, "fingerprint" | "updatedAt">): void;
+    /** Update the axes on an existing node. Schema-validates the result. */
+    updateNodeAxes(id: string, axes: Record<string, string>): GraphNode;
+    /** Remove a node. Refuses to delete if any other node still references it
+     *  (child via parentId, or axis ref). */
+    deleteNode(id: string): void;
+    /** Approve a pending classification. Commits any new nodes along its path,
+     *  stamps the fingerprint index so future similar messages hit the cache,
+     *  and appends an audit entry. Idempotent — no-op if already cached. */
+    approveClassification(c: Classification): void;
+    /** Record rejection — no nodes committed, no fingerprint set. */
+    rejectClassification(c: Classification): void;
+}
+
 interface ProviderCapabilities {
     streaming: boolean;
     tools: boolean;
@@ -4666,6 +5720,17 @@ declare const logger: {
 
 declare function handleError(error: unknown): void;
 
+/**
+ * Read the agentx-cli package.json so commands like --version work.
+ *
+ * Looks in three places, in order:
+ *   1. A package.json beside the compiled entry (dist/cli.js → ../package.json),
+ *      which is how npm-installed usage finds it.
+ *   2. A package.json in the CWD, which is what `pnpm dev` / `tsx src/cli.ts`
+ *      implicitly relies on.
+ *   3. A safe fallback so the CLI never crashes on a truly bare environment
+ *      (e.g. a fresh user running `agentx setup` from an empty temp dir).
+ */
 declare function getPackageInfo(): PackageJson;
 
-export { A2AClient, A2AMesh, A2AServer, A2AServerConfig, ALL_TOOL_NAMES, AgentCard, AgentConfig, AgentContext, AgentDef, AgentProvider, AgentRegistry, AgentResponse, AgentTask, AgentXDaemon, AgentXRuntime, AnthropicMessage, AuthConfig, BLOCKING_EVENTS, ChannelAdapter, ClaudeCodeProvider, ClaudeProvider, ContentBlock, ContextBuilder, CronJobDef, CronJobState, CronRunResult, CronScheduler, DaemonConfig, EnhanceConfig, EnhanceEngine, EnhanceResult, GenerateOptions, GenerateResult, GenerateStreamEvent, GeneratedFile, GenerationMessage, GenerationResult, GitCommitResult, GitDiffFile, GitLogEntry, GitManager, GitStatus, HOOK_EVENTS, HealConfig, HealEngine, HealResult, HookContext, HookDefinition, HookEvent, HookHandler, HookRegistry, HookResult, IncomingMessage, Memory, MemoryEntry, MemoryHierarchy, MemoryStore, MeshPeer, MessageRouter, MiddlewareFn, ModelUsage, OUTPUT_CONFIGS, OUTPUT_TYPES, OutgoingMessage, OutputConfig, OutputType, PERMISSION_MODES, PROVIDER_CAPABILITIES, PermissionAction, PermissionConfig, PermissionManager, PermissionMode, PermissionRule, Pipeline, PipelineRequest, PipelineResponse, ProjectSchemas, ProviderCapabilities, ProviderName, ProviderOptions, RawGenerationResult, ReplEngine, ReplOptions, RuntimeConfig, Session, StepUsage, StreamEvent, Task, TaskArtifact, TaskMessage, TaskState, TaskStatusUpdate, TechStack, TelegramAdapter, ToolCallInput, ToolExecutor, ToolExecutorOptions, ToolResult, UsageSummary, UsageTracker, WhatsAppAdapter, WikiAccess, WikiArticle, WikiArticleMeta, WikiEntry, WikiIndex, WikiStore, agentConfigSchema$1 as agentConfigSchema, checkCapabilities, createAgentContext, createProvider, createSession, daemonConfigSchema, debug, detectSchemas, detectTechStack, ensureCredentials, executeClaudeCode, executeOrchestrator, executeSdk, executeTask, exportSession, formatSchemas, formatTechStack, formatToolsForSystemPrompt, gatherContext7Docs, generate, generateSkill, generateSkillMd, generateStream, getAnthropicTools, getCommand, getLegacyTools, getPackageInfo, globalHooks, globalPermissions, globalTracker, handleError, installSkillPackage, isCommand, isDebug, listInstalledSkills, listSessions, loadAuthConfig, loadDaemonConfig, loadHooks, loadLatestSession, loadLocalSkills, loadProjectInstructions, loadSession, logger, matchSkillsToTask, outputTypeDescriptions, parseCommand, parseSkillContent, parseSkillFile, permissionConfigSchema, permissionModeSchema, registerCommand, resolveAtImports, resolveOutputType, resolveToken, runModelSetup, saveAuthConfig, saveSession, setDebug, startMcpServer, validateWorkspaces };
+export { A2AClient, A2AMesh, A2AServer, A2AServerConfig, ALL_TOOL_NAMES, AgentCard, AgentConfig, AgentContext, AgentDef, AgentProvider, AgentRegistry, AgentResponse, AgentTask, AgentXDaemon, AgentXRuntime, AnthropicMessage, AuthConfig, AxisDef, AxisType, BLOCKING_EVENTS, ChannelAdapter, Classification, ClassificationSource, ClassificationStatus, ClaudeCodeProvider, ClaudeProvider, ContentBlock, ContextBuilder, CronJobDef, CronJobState, CronRunResult, CronScheduler, DaemonConfig, EnhanceConfig, EnhanceEngine, EnhanceResult, FingerprintEntry, GenerateOptions, GenerateResult, GenerateStreamEvent, GeneratedFile, GenerationMessage, GenerationResult, GitCommitResult, GitDiffFile, GitLogEntry, GitManager, GitStatus, GraphNode, GraphSchema, GraphStore, GraphStoreOptions, HOOK_EVENTS, HealConfig, HealEngine, HealResult, HookContext, HookDefinition, HookEvent, HookHandler, HookRegistry, HookResult, IncomingMessage, IndexFile, LevelDef, Memory, MemoryEntry, MemoryHierarchy, MemoryStore, MeshPeer, MessageRouter, MiddlewareFn, ModelUsage, NodesFile, OUTPUT_CONFIGS, OUTPUT_TYPES, OutgoingMessage, OutputConfig, OutputType, PERMISSION_MODES, PROVIDER_CAPABILITIES, PermissionAction, PermissionConfig, PermissionManager, PermissionMode, PermissionRule, Pipeline, PipelineRequest, PipelineResponse, ProjectSchemas, ProviderCapabilities, ProviderName, ProviderOptions, RawGenerationResult, ReplEngine, ReplOptions, RuntimeConfig, STARTER_SCHEMA, Session, StepUsage, StreamEvent, Task, TaskArtifact, TaskMessage, TaskState, TaskStatusUpdate, TechStack, TelegramAdapter, ToolCallInput, ToolExecutor, ToolExecutorOptions, ToolResult, UsageSummary, UsageTracker, WhatsAppAdapter, WikiAccess, WikiArticle, WikiArticleMeta, WikiEntry, WikiIndex, WikiStore, agentConfigSchema$1 as agentConfigSchema, checkCapabilities, createAgentContext, createProvider, createSession, daemonConfigSchema, debug, detectSchemas, detectTechStack, ensureCredentials, executeClaudeCode, executeOrchestrator, executeSdk, executeTask, exportSession, formatSchemas, formatTechStack, formatToolsForSystemPrompt, gatherContext7Docs, generate, generateSkill, generateSkillMd, generateStream, getAnthropicTools, getCommand, getLegacyTools, getPackageInfo, globalHooks, globalPermissions, globalTracker, handleError, installSkillPackage, isCommand, isDebug, listInstalledSkills, listSessions, loadAuthConfig, loadDaemonConfig, loadHooks, loadLatestSession, loadLocalSkills, loadProjectInstructions, loadSession, logger, matchSkillsToTask, outputTypeDescriptions, parseCommand, parseSkillContent, parseSkillFile, permissionConfigSchema, permissionModeSchema, registerCommand, resolveAtImports, resolveOutputType, resolveToken, runModelSetup, saveAuthConfig, saveSession, setDebug, startMcpServer, validateWorkspaces };