agentix-cli 0.17.0 → 0.19.0

package/dist/index.d.ts

@@ -262,7 +262,7 @@ interface UserPreference {
     confidence: number;
     source: string;
 }
-interface MemoryStore {
+interface MemoryStore$1 {
     version: number;
     entries: MemoryEntry[];
     patterns: LearnedPattern[];
@@ -293,7 +293,7 @@ declare class Memory {
     getSimilarTasks(task: string, limit?: number): MemoryEntry[];
     getPatterns(): LearnedPattern[];
     getPreferences(): UserPreference[];
-    getStats(): MemoryStore["stats"];
+    getStats(): MemoryStore$1["stats"];
     buildMemoryContext(task: string): string;
     private extractPattern;
     private updateSuccessRate;
@@ -413,6 +413,15 @@ declare const skillFrontmatterSchema: z.ZodObject<{
     }>, "many">>;
     /** If true, skill is auto-injected into context when triggers match (per-turn) */
     autoInject: z.ZodOptional<z.ZodBoolean>;
+    /** Reference card ids cited by this skill (e.g. "ksi.gitlab.project.ksi-v2").
+     *  Audit lint flags FAILING when any id does not resolve. */
+    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Skills this one delegates to (e.g. ksi-cx-email → [hotmail]). Audit lint
+     *  flags FAILING when a delegate has no SKILL.md. */
+    delegatesTo: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Free-form category — used by recipes and audit rules. Common values:
+     *  deploy, ssh, email, gitlab, ops, content, marketing. */
+    category: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
@@ -425,6 +434,9 @@ declare const skillFrontmatterSchema: z.ZodObject<{
         description?: string | undefined;
     }[] | undefined;
     autoInject?: boolean | undefined;
+    references?: string[] | undefined;
+    delegatesTo?: string[] | undefined;
+    category?: string | undefined;
 }, {
     name: string;
     description: string;
@@ -437,6 +449,9 @@ declare const skillFrontmatterSchema: z.ZodObject<{
         description?: string | undefined;
     }[] | undefined;
     autoInject?: boolean | undefined;
+    references?: string[] | undefined;
+    delegatesTo?: string[] | undefined;
+    category?: string | undefined;
 }>;
 type SkillFrontmatter = z.infer<typeof skillFrontmatterSchema>;
 interface Skill {
@@ -758,8 +773,8 @@ declare class MemoryHierarchy {
      * Get stats from both levels.
      */
     getStats(): {
-        user: MemoryStore["stats"];
-        project: MemoryStore["stats"];
+        user: MemoryStore$1["stats"];
+        project: MemoryStore$1["stats"];
     };
     /**
      * Get recent generations from project level.
@@ -833,7 +848,7 @@ declare const debug: {
     channel(name: string, event: string, detail?: string): void;
 };
 
-interface Session {
+interface Session$1 {
     id: string;
     createdAt: string;
     updatedAt: string;
@@ -845,25 +860,25 @@ interface Session {
 /**
  * Create a new session.
  */
-declare function createSession(cwd: string): Session;
+declare function createSession(cwd: string): Session$1;
 /**
  * Save a session to disk.
  */
-declare function saveSession(session: Session): void;
+declare function saveSession(session: Session$1): void;
 /**
  * Load a session from disk.
  */
-declare function loadSession(id: string): Session | null;
+declare function loadSession(id: string): Session$1 | null;
 /**
  * Load the most recent session.
  */
-declare function loadLatestSession(): Session | null;
+declare function loadLatestSession(): Session$1 | null;
 /**
  * List all saved sessions.
  */
-declare function listSessions(): Session[];
+declare function listSessions(): Session$1[];
 
-declare function exportSession(session: Session, usage?: UsageSummary): string;
+declare function exportSession(session: Session$1, usage?: UsageSummary): string;
 
 declare const PERMISSION_MODES: readonly ["default", "acceptEdits", "plan", "yolo"];
 type PermissionMode = (typeof PERMISSION_MODES)[number];
@@ -1151,9 +1166,9 @@ declare class ReplEngine {
 }
 
 interface CommandContext {
-    session: Session;
+    session: Session$1;
     cwd: string;
-    onSessionChange: (session: Session) => void;
+    onSessionChange: (session: Session$1) => void;
 }
 type SlashCommandHandler = (args: string, ctx: CommandContext) => Promise<boolean>;
 declare function registerCommand(name: string, handler: SlashCommandHandler): void;
@@ -1299,6 +1314,52 @@ declare const agentConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
     mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Phase 5 — typed capabilities (drop-condition fallback). Free-form
+     *  list of intent strings this agent is allowed to handle. When set,
+     *  the org-chart `canHandle(agentId, project, intent)` check rejects
+     *  dispatches with intents not in this list. When empty/unset
+     *  (the default), the agent is permissive — handles any intent.
+     *  Intent matching is exact-string for now; a glob/prefix layer can
+     *  come later if it produces real rejections.
+     *  Example: ["issue.opened", "issue.commented", "merge_request.opened"]
+     *  Example: ["cron.fired", "message.received"]              */
+    intents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Phase 8 — capability-bounded security. Max distinct upstream
+     *  agents in the delegation chain on the same (project, subject)
+     *  before a dispatch to THIS agent is refused. The ledger itself
+     *  provides the chain — `decideAndCommit` walks recent decisions on
+     *  the subject and counts distinct agents. Default 5; set to 0 to
+     *  disable for an agent that's always called as the bottom of a
+     *  chain. The check prevents cascade loops where A → B → A → B → ...
+     *  blows past sane chain depth. */
+    maxDelegationDepth: z.ZodDefault<z.ZodNumber>;
+    /** MCP servers this agent's Claude Code session should load. Synced
+     *  to <workspace>/.mcp.json at daemon boot via agent-mcp.ts. Operator
+     *  edits to .mcp.json are respected (see SyncResult.skipped-operator-owned). */
+    mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args: string[];
+        env?: Record<string, string> | undefined;
+    }, {
+        command: string;
+        env?: Record<string, string> | undefined;
+        args?: string[] | undefined;
+    }>>>;
+    /** Per-agent override for the global `session.contextStrategy`. Lets
+     *  one agent run `planner` (smaller upfront context, more tool-driven
+     *  exploration) while siblings stay on `layered`. Used for agents that
+     *  consistently bloat their cache via large workspace reads. */
+    contextStrategy: z.ZodOptional<z.ZodEnum<["layered", "planner"]>>;
+    /** When true, the registry resolves references-recipes for this agent's
+     *  workspace and renders a deterministic [Verified References] block at
+     *  priority 4.7. Off by default — flip on per agent (pm-ksi, devops-agent,
+     *  etc.) once a `references/` registry exists in the agent's workspace
+     *  or repo root. See src/agents/references/. */
+    contextReferences: z.ZodDefault<z.ZodBoolean>;
     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
@@ -1332,6 +1393,9 @@ declare const agentConfigSchema: z.ZodObject<{
     workspace: string;
     tier: "claude-code" | "sdk" | "orchestrator";
     mentions: string[];
+    intents: string[];
+    maxDelegationDepth: number;
+    contextReferences: boolean;
     maxConcurrent: number;
     maxExecutionMinutes: number;
     permissionMode: string;
@@ -1346,6 +1410,12 @@ declare const agentConfigSchema: z.ZodObject<{
     provider?: string | undefined;
     model?: string | undefined;
     systemPrompt?: string | undefined;
+    mcp?: Record<string, {
+        command: string;
+        args: string[];
+        env?: Record<string, string> | undefined;
+    }> | undefined;
+    contextStrategy?: "layered" | "planner" | undefined;
 }, {
     name: string;
     workspace: string;
@@ -1354,6 +1424,15 @@ declare const agentConfigSchema: z.ZodObject<{
     tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
     systemPrompt?: string | undefined;
     mentions?: string[] | undefined;
+    intents?: string[] | undefined;
+    maxDelegationDepth?: number | undefined;
+    mcp?: Record<string, {
+        command: string;
+        env?: Record<string, string> | undefined;
+        args?: string[] | undefined;
+    }> | undefined;
+    contextStrategy?: "layered" | "planner" | undefined;
+    contextReferences?: boolean | undefined;
     maxConcurrent?: number | undefined;
     maxExecutionMinutes?: number | undefined;
     permissionMode?: string | undefined;
@@ -1475,6 +1554,52 @@ declare const daemonConfigSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Phase 5 — typed capabilities (drop-condition fallback). Free-form
+         *  list of intent strings this agent is allowed to handle. When set,
+         *  the org-chart `canHandle(agentId, project, intent)` check rejects
+         *  dispatches with intents not in this list. When empty/unset
+         *  (the default), the agent is permissive — handles any intent.
+         *  Intent matching is exact-string for now; a glob/prefix layer can
+         *  come later if it produces real rejections.
+         *  Example: ["issue.opened", "issue.commented", "merge_request.opened"]
+         *  Example: ["cron.fired", "message.received"]              */
+        intents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Phase 8 — capability-bounded security. Max distinct upstream
+         *  agents in the delegation chain on the same (project, subject)
+         *  before a dispatch to THIS agent is refused. The ledger itself
+         *  provides the chain — `decideAndCommit` walks recent decisions on
+         *  the subject and counts distinct agents. Default 5; set to 0 to
+         *  disable for an agent that's always called as the bottom of a
+         *  chain. The check prevents cascade loops where A → B → A → B → ...
+         *  blows past sane chain depth. */
+        maxDelegationDepth: z.ZodDefault<z.ZodNumber>;
+        /** MCP servers this agent's Claude Code session should load. Synced
+         *  to <workspace>/.mcp.json at daemon boot via agent-mcp.ts. Operator
+         *  edits to .mcp.json are respected (see SyncResult.skipped-operator-owned). */
+        mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            command: string;
+            args: string[];
+            env?: Record<string, string> | undefined;
+        }, {
+            command: string;
+            env?: Record<string, string> | undefined;
+            args?: string[] | undefined;
+        }>>>;
+        /** Per-agent override for the global `session.contextStrategy`. Lets
+         *  one agent run `planner` (smaller upfront context, more tool-driven
+         *  exploration) while siblings stay on `layered`. Used for agents that
+         *  consistently bloat their cache via large workspace reads. */
+        contextStrategy: z.ZodOptional<z.ZodEnum<["layered", "planner"]>>;
+        /** When true, the registry resolves references-recipes for this agent's
+         *  workspace and renders a deterministic [Verified References] block at
+         *  priority 4.7. Off by default — flip on per agent (pm-ksi, devops-agent,
+         *  etc.) once a `references/` registry exists in the agent's workspace
+         *  or repo root. See src/agents/references/. */
+        contextReferences: z.ZodDefault<z.ZodBoolean>;
         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
@@ -1508,6 +1633,9 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
+        intents: string[];
+        maxDelegationDepth: number;
+        contextReferences: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
@@ -1522,6 +1650,12 @@ declare const daemonConfigSchema: z.ZodObject<{
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
+        mcp?: Record<string, {
+            command: string;
+            args: string[];
+            env?: Record<string, string> | undefined;
+        }> | undefined;
+        contextStrategy?: "layered" | "planner" | undefined;
     }, {
         name: string;
         workspace: string;
@@ -1530,6 +1664,15 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
+        intents?: string[] | undefined;
+        maxDelegationDepth?: number | undefined;
+        mcp?: Record<string, {
+            command: string;
+            env?: Record<string, string> | undefined;
+            args?: string[] | undefined;
+        }> | undefined;
+        contextStrategy?: "layered" | "planner" | undefined;
+        contextReferences?: boolean | undefined;
         maxConcurrent?: number | undefined;
         maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
@@ -2705,10 +2848,53 @@ declare const daemonConfigSchema: z.ZodObject<{
             reportsTo?: string | undefined;
             utilizationTarget?: number | undefined;
         }>>>;
+        projects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            pm: z.ZodOptional<z.ZodString>;
+            client: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }, {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }>, "many">>;
+        contactMap: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            channel: z.ZodOptional<z.ZodString>;
+            chatId: z.ZodOptional<z.ZodString>;
+            username: z.ZodOptional<z.ZodString>;
+            senderId: z.ZodOptional<z.ZodString>;
+            client: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }, {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }>, "many">>;
         workTickMinutes: z.ZodDefault<z.ZodNumber>;
         idleQueueThreshold: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
+        projects: {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }[];
         timezone: string;
         mainChannel: {
             channel: string;
@@ -2746,6 +2932,15 @@ declare const daemonConfigSchema: z.ZodObject<{
             utilizationTarget: number;
             reportsTo?: string | undefined;
         }>;
+        contactMap: {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }[];
         workTickMinutes: number;
         idleQueueThreshold: number;
     }, {
@@ -2766,6 +2961,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             glob?: string | undefined;
         };
         enabled?: boolean | undefined;
+        projects?: {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }[] | undefined;
         timezone?: string | undefined;
         roles?: Record<string, {
             title: string;
@@ -2787,6 +2987,15 @@ declare const daemonConfigSchema: z.ZodObject<{
             reportsTo?: string | undefined;
             utilizationTarget?: number | undefined;
         }> | undefined;
+        contactMap?: {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }[] | undefined;
         workTickMinutes?: number | undefined;
         idleQueueThreshold?: number | undefined;
     }>>;
@@ -2937,7 +3146,6 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: z.ZodString;
             dashboardUrl: z.ZodOptional<z.ZodString>;
             token: z.ZodOptional<z.ZodString>;
-            /** Phone numbers or JIDs. Substring match, same semantics as allowFrom. */
             dashboardToken: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             name: string;
@@ -2952,8 +3160,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             dashboardUrl?: string | undefined;
             dashboardToken?: string | undefined;
         }>, "many">>;
-        draftAgent: z.ZodOptional<z.ZodString>; /** Safety rails on live Baileys reads — personal-account accounts
-         *  can get throttled/banned under burst reads. */
+        draftAgent: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         port: number;
@@ -3012,6 +3219,11 @@ declare const daemonConfigSchema: z.ZodObject<{
          *  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>;
+        /** Anthropic model id used for the direct classifier call (Phase 2 of
+         *  classifier-retire). Default haiku — classification is metadata, not
+         *  work, so we use the cheapest fast model. Override only if Haiku is
+         *  rate-limited or you want to A/B test. */
+        classifierModel: z.ZodDefault<z.ZodString>;
         /** 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<{
@@ -3029,6 +3241,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseDir: string;
         autoApproveStructure: "any" | "strict" | "extend-leaves";
         autoApproveConfidence: number;
+        classifierModel: string;
         retrievalWeights: {
             graph: number;
             bm25: number;
@@ -3042,6 +3255,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         reviewAgent?: string | undefined;
         autoApproveStructure?: "any" | "strict" | "extend-leaves" | undefined;
         autoApproveConfidence?: number | undefined;
+        classifierModel?: string | undefined;
         retrievalWeights?: {
             graph?: number | undefined;
             bm25?: number | undefined;
@@ -3078,22 +3292,43 @@ declare const daemonConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         /** Route to a mesh peer instead of local execution. */
         node: z.ZodOptional<z.ZodString>;
+        /** Per-event-type workflow routing. Keys are platform event-type
+         *  strings — the format the platform's HTTP header uses, optionally
+         *  joined with the action. Examples:
+         *    GitHub: "issues.opened", "pull_request.synchronize",
+         *            "push" (action-less events use the bare type)
+         *    GitLab: "Note Hook", "Merge Request Hook"
+         *  Values are workflow ids registered via `agentx workflow create`.
+         *  When the inbound event-type matches a key, the named workflow is
+         *  dispatched; if no key matches, the webhook falls through to
+         *  `defaultWorkflow` (or the agent itself). Closes the recurring
+         *  GitHub problem of multiple event types collapsing to a single
+         *  workflow. */
+        triggers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        /** Workflow id used when no `triggers` entry matches the event-type.
+         *  Backward-compatible: pre-existing webhooks without `triggers`
+         *  always hit this path. */
+        defaultWorkflow: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         id: string;
         source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
         agentId: string;
         description?: string | undefined;
+        triggers?: Record<string, string> | undefined;
         node?: string | undefined;
         secretEnv?: string | undefined;
+        defaultWorkflow?: string | undefined;
     }, {
         id: string;
         source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
         agentId: string;
         enabled?: boolean | undefined;
         description?: string | undefined;
+        triggers?: Record<string, string> | undefined;
         node?: string | undefined;
         secretEnv?: string | undefined;
+        defaultWorkflow?: string | undefined;
     }>, "many">>;
     /** Session cache-reuse policy. Controls when we drop a Claude `--resume`
      *  session and rebuild the prompt from scratch.
@@ -3130,26 +3365,37 @@ declare const daemonConfigSchema: z.ZodObject<{
         maxClaudeCodeDispatchesPerHour: z.ZodDefault<z.ZodNumber>;
         maxClaudeCodeDispatchesPer5h: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
+        contextStrategy: "layered" | "planner";
         staleMinutes: number;
         maxTurnsPerSession: number;
         tierTwoThresholdTokens: number;
-        contextStrategy: "layered" | "planner";
         maxClaudeCodeDispatchesPerHour: number;
         maxClaudeCodeDispatchesPer5h: number;
     }, {
+        contextStrategy?: "layered" | "planner" | undefined;
         staleMinutes?: number | undefined;
         maxTurnsPerSession?: number | undefined;
         tierTwoThresholdTokens?: number | undefined;
-        contextStrategy?: "layered" | "planner" | undefined;
         maxClaudeCodeDispatchesPerHour?: number | undefined;
         maxClaudeCodeDispatchesPer5h?: number | undefined;
     }>>;
+    /** Move B — JS/TS plugins. Each entry is an installed npm package name
+     *  (e.g. `agentx-plugin-mattermost` or `@noqta/plugin-mattermost`); the
+     *  loader does a dynamic `import(name)` at boot, validates the manifest,
+     *  and calls plugin.setup(ctx). Plugins can register channel adapters
+     *  via ctx.addChannel() and subscribe to bus events via ctx.on(). Empty
+     *  default — installs that don't list plugins are unaffected. Plugin
+     *  authoring guide: docs/architecture/plugins.md. */
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     agents: Record<string, {
         name: string;
         workspace: string;
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
+        intents: string[];
+        maxDelegationDepth: number;
+        contextReferences: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
@@ -3164,6 +3410,12 @@ declare const daemonConfigSchema: z.ZodObject<{
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
+        mcp?: Record<string, {
+            command: string;
+            args: string[];
+            env?: Record<string, string> | undefined;
+        }> | undefined;
+        contextStrategy?: "layered" | "planner" | undefined;
     }>;
     mesh: {
         enabled: boolean;
@@ -3189,6 +3441,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseDir: string;
         autoApproveStructure: "any" | "strict" | "extend-leaves";
         autoApproveConfidence: number;
+        classifierModel: string;
         retrievalWeights: {
             graph: number;
             bm25: number;
@@ -3428,19 +3681,27 @@ declare const daemonConfigSchema: z.ZodObject<{
         source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
         agentId: string;
         description?: string | undefined;
+        triggers?: Record<string, string> | undefined;
         node?: string | undefined;
         secretEnv?: string | undefined;
+        defaultWorkflow?: string | undefined;
     }[];
     session: {
+        contextStrategy: "layered" | "planner";
         staleMinutes: number;
         maxTurnsPerSession: number;
         tierTwoThresholdTokens: number;
-        contextStrategy: "layered" | "planner";
         maxClaudeCodeDispatchesPerHour: number;
         maxClaudeCodeDispatchesPer5h: number;
     };
+    plugins: string[];
     business?: {
         enabled: boolean;
+        projects: {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }[];
         timezone: string;
         mainChannel: {
             channel: string;
@@ -3478,6 +3739,15 @@ declare const daemonConfigSchema: z.ZodObject<{
             utilizationTarget: number;
             reportsTo?: string | undefined;
         }>;
+        contactMap: {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }[];
         workTickMinutes: number;
         idleQueueThreshold: number;
     } | undefined;
@@ -3496,6 +3766,15 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
+        intents?: string[] | undefined;
+        maxDelegationDepth?: number | undefined;
+        mcp?: Record<string, {
+            command: string;
+            env?: Record<string, string> | undefined;
+            args?: string[] | undefined;
+        }> | undefined;
+        contextStrategy?: "layered" | "planner" | undefined;
+        contextReferences?: boolean | undefined;
         maxConcurrent?: number | undefined;
         maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
@@ -3528,6 +3807,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         reviewAgent?: string | undefined;
         autoApproveStructure?: "any" | "strict" | "extend-leaves" | undefined;
         autoApproveConfidence?: number | undefined;
+        classifierModel?: string | undefined;
         retrievalWeights?: {
             graph?: number | undefined;
             bm25?: number | undefined;
@@ -3725,6 +4005,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             glob?: string | undefined;
         };
         enabled?: boolean | undefined;
+        projects?: {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }[] | undefined;
         timezone?: string | undefined;
         roles?: Record<string, {
             title: string;
@@ -3746,6 +4031,15 @@ declare const daemonConfigSchema: z.ZodObject<{
             reportsTo?: string | undefined;
             utilizationTarget?: number | undefined;
         }> | undefined;
+        contactMap?: {
+            client: string;
+            channel?: string | undefined;
+            chatId?: string | undefined;
+            username?: string | undefined;
+            senderId?: string | undefined;
+            project?: string | undefined;
+            displayName?: string | undefined;
+        }[] | undefined;
         workTickMinutes?: number | undefined;
         idleQueueThreshold?: number | undefined;
     } | undefined;
@@ -3807,17 +4101,20 @@ declare const daemonConfigSchema: z.ZodObject<{
         agentId: string;
         enabled?: boolean | undefined;
         description?: string | undefined;
+        triggers?: Record<string, string> | undefined;
         node?: string | undefined;
         secretEnv?: string | undefined;
+        defaultWorkflow?: string | undefined;
     }[] | undefined;
     session?: {
+        contextStrategy?: "layered" | "planner" | undefined;
         staleMinutes?: number | undefined;
         maxTurnsPerSession?: number | undefined;
         tierTwoThresholdTokens?: number | undefined;
-        contextStrategy?: "layered" | "planner" | undefined;
         maxClaudeCodeDispatchesPerHour?: number | undefined;
         maxClaudeCodeDispatchesPer5h?: number | undefined;
     } | undefined;
+    plugins?: string[] | undefined;
 }>;
 type DaemonConfig = z.infer<typeof daemonConfigSchema>;
 type AgentDef = z.infer<typeof agentConfigSchema>;
@@ -3851,6 +4148,14 @@ declare class A2AMesh {
     private healthTimer?;
     private config;
     private log;
+    /** Optional callback fired on peer state transitions (recovered /
+     *  lost / skills changed). Daemon wires this to the event bus for
+     *  live operator visibility. */
+    private peerChangeCallback?;
+    /** Register a listener for peer state transitions. Only one listener
+     *  is kept — repeat calls overwrite. Used by the daemon to bridge
+     *  into the EventBus without introducing a circular dependency. */
+    onPeerChange(cb: typeof A2AMesh.prototype.peerChangeCallback): void;
     constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
     /**
      * Start the mesh: discover peers and begin health checks.
@@ -3867,6 +4172,28 @@ declare class A2AMesh {
         removed: string[];
         updated: string[];
     }>;
+    /** Number of peers currently registered (regardless of health). */
+    peerCount(): number;
+    /**
+     * Re-probe a single peer immediately. Use case: an operator just added
+     * an agent on the remote daemon and doesn't want to wait up to a full
+     * health-check interval (default 60s) before mentioning the new agent
+     * resolves. The probe pulls a fresh agent card and updates `state.agents`
+     * so `directory()` reflects the new roster on the very next route lookup.
+     *
+     * Returns true on success, false when the peer is unknown or the probe
+     * failed. Does NOT throw — callers can blindly fan-out across peers.
+     */
+    refreshPeer(name: string): Promise<boolean>;
+    /**
+     * Re-probe every peer in parallel. Cheap when peers are healthy
+     * (single GET /a2a/agent-card per peer). Used by `agentx mesh refresh`
+     * and after agent-roster changes to invalidate the cached directory.
+     */
+    refreshAll(): Promise<{
+        name: string;
+        healthy: boolean;
+    }[]>;
     /**
      * Discover agent cards from all peers.
      */
@@ -3879,6 +4206,21 @@ declare class A2AMesh {
      */
     sendTask(peerName: string, text: string, agentId?: string, opts?: {
         timeoutMs?: number;
+        /** Identity of the agent on whose behalf this call is made. Forwarded
+         *  in the request body so the receiving daemon can record it in
+         *  route_traces and (in a future protocol revision) validate that the
+         *  caller is allowed to act for this agent. Optional during the
+         *  log-warn rollout; missing values produce a server-side warning. */
+        senderAgentId?: string;
+        /** Origin context — channel, chatId, sender, channelMeta, etc. Forwarded
+         *  to the receiving daemon's /task handler verbatim so the receiver's
+         *  registry.execute() keys the session by the SAME (channel, chatId)
+         *  the sender used, instead of falling back to api/default. Without
+         *  this, a GitLab webhook routed across the mesh lands in the
+         *  recipient's api:default bucket with no project, no issue id, no
+         *  channelMeta — i.e., the mtgl/hasanah confusion incident on
+         *  2026-04-29 issue #709. Shape matches AgentTask.context. */
+        context?: Record<string, unknown>;
     }): Promise<string>;
     /**
      * Forward a WebRTC signaling message (SDP / ICE / hangup) to a remote peer's
@@ -3919,6 +4261,99 @@ declare class A2AMesh {
     }>;
 }
 
+type EventKind = "run" | "task" | "signal" | "mesh" | "channel" | "status";
+interface BaseEvent {
+    kind: EventKind;
+    /** Monotonic-ish identifier; just for debug/replay. */
+    id: string;
+    /** ISO-8601 emit time. */
+    at: string;
+}
+interface RunEvent extends BaseEvent {
+    kind: "run";
+    runId: string;
+    workflowId: string;
+    /** Node that just transitioned. Optional for run-created events. */
+    nodeId?: string;
+    /** "created" | "ok" | "failed" | "paused" | "resumed" | "skipped" | "completed" | "timeout". */
+    phase: string;
+    /** Current run status after the transition. */
+    status?: string;
+    homeNode?: string;
+    note?: string;
+}
+interface TaskEvent extends BaseEvent {
+    kind: "task";
+    taskId: string;
+    workflowId: string;
+    runId: string;
+    phase: "created" | "submitted" | "canceled";
+    assignedTo?: string[];
+    title?: string;
+    submittedBy?: string;
+}
+interface SignalEvent extends BaseEvent {
+    kind: "signal";
+    name: string;
+    scope: "workflow" | "global";
+    workflowId?: string;
+    payload?: Record<string, unknown>;
+}
+interface MeshEvent extends BaseEvent {
+    kind: "mesh";
+    peer: string;
+    healthy: boolean;
+    skills?: string[];
+    delta: "recovered" | "lost" | "skills-changed" | "added" | "removed";
+}
+interface ChannelEvent extends BaseEvent {
+    kind: "channel";
+    channel: string;
+    direction: "in" | "out";
+    chatId?: string;
+    sender?: string;
+    agentId?: string;
+    textPreview?: string;
+    messageId?: string;
+}
+interface StatusEvent extends BaseEvent {
+    kind: "status";
+    message: string;
+    meta?: Record<string, unknown>;
+}
+type DaemonEvent = RunEvent | TaskEvent | SignalEvent | MeshEvent | ChannelEvent | StatusEvent;
+interface SubscriptionFilter {
+    /** Match only these kinds. Empty / omitted = all kinds. */
+    kinds?: EventKind[];
+    /** Workflow id filter (applies to run/task/signal events). */
+    workflowId?: string;
+    /** Actor id filter (task.assignedTo includes this, or task.submittedBy equals). */
+    actor?: string;
+    /** Channel filter (for channel events). */
+    channel?: string;
+    /** Run id filter (run events for a specific run). */
+    runId?: string;
+}
+type Listener = (e: DaemonEvent) => void;
+/** Simple in-memory publish/subscribe. No ordering guarantees beyond
+ *  "subscribers see events in the order they were published". No
+ *  durability. Listener callbacks are invoked synchronously; if a
+ *  listener throws, the error is swallowed so a single bad subscriber
+ *  can't break the fanout. */
+declare class EventBus {
+    private listeners;
+    subscribe(filter: SubscriptionFilter, fn: Listener): () => void;
+    /** Publish an event. The `id` and `at` fields are filled in if absent.
+     *  We deliberately accept a loose input shape — callers construct the
+     *  per-kind literal and we trust them; runtime validation happens at
+     *  the SSE serialisation layer. */
+    publish(event: {
+        kind: EventKind;
+    } & Record<string, unknown>): void;
+    /** Active subscriber count — useful for health endpoints. */
+    get size(): number;
+}
+
 declare class AgentXDaemon {
     private config;
     private registry;
@@ -3937,12 +4372,11 @@ declare class AgentXDaemon {
     private workflowDispatcher?;
     private workflowStore?;
     private workflowRuns?;
-    /** Structured per-agent memory (Claude-Code-style user / feedback /
-     *  project / reference). Deliberately owned by the daemon (not the
-     *  registry) so HTTP callers — including an agent curling from its
-     *  own Claude Code session — can write without going through the
-     *  dispatcher. Inlined into agent system prompts happens elsewhere. */
+    private db;
+    private loadedPlugins;
     private readonly agentMemory;
+    private contacts;
+    readonly events: EventBus;
     private log;
     private sseClients;
     private configPath?;
@@ -4018,12 +4452,24 @@ declare class AgentXDaemon {
      */
     private handleOpenAICompat;
     private json;
+    /** Pick today's usage rollup according to AGENTX_USAGE_READ:
+     *    - "sqlite": SQLite only (empty if db null / no rows)
+     *    - "json":   JSON only (legacy behaviour)
+     *    - "sqlite-then-json" (default): try SQLite, fall back to JSON when
+     *      the rollup is empty (no agents seen today). Transparent for
+     *      operators on first deploy where SQLite is empty until the first
+     *      task completes. */
+    private resolveTodayUsage;
     /** Boot-time: install the `remember` skill into every agent workspace
      *  that doesn't already have it, and sync each agent's existing memory
      *  into <workspace>/CLAUDE.md + .agentx-memory.md. Idempotent — safe to
      *  run on every daemon start. Write-if-absent for the skill, sentinel-
      *  replace for CLAUDE.md, so operator edits survive. */
     private installAgentMemorySurface;
+    /** Boot-time: sync each agent's `mcp` config block to
+     *  <workspace>/.mcp.json. Mirrors installAgentMemorySurface — same
+     *  ownership semantics, marker-based to preserve operator edits. */
+    private installAgentMcpConfig;
     /** Look up an agent's workspace from the live registry. Returns null
      *  for agents the daemon doesn't know about (e.g., a stale memory
      *  entry for a since-removed agent). */
@@ -4269,6 +4715,19 @@ interface AgentTask {
      *  supports it. Workflow `agent` nodes pass this through from their
      *  config.timeoutMinutes. */
     timeoutMinutes?: number;
+    /** Phase 1 / 6 — when set, identifies the intent-ledger decision row
+     *  this task corresponds to. The registry records a resolution row
+     *  on this decision when the task completes (success / error / mesh-
+     *  fallback). Active-task safety in `decideAndCommit` reads
+     *  intent_resolutions to clear in-flight slots; without resolution
+     *  writes, every dispatched decision sits in-flight forever and
+     *  Inv-ActiveTaskSafety becomes vacuously over-aggressive. Channel
+     *  adapters (gitlab, router) set this when their record*Dispatch
+     *  helper returns a dispatched decision. */
+    intentRef?: {
+        eventId: string;
+        decidedBy: string;
+    };
     context?: {
         channel?: string;
         sender?: string;
@@ -4359,6 +4818,464 @@ declare function executeTask(agent: AgentDef, task: AgentTask, providers: Record
     apiKey?: string;
 }>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void): Promise<AgentResponse>;
 
+interface DriftReport {
+    /** 0-1 score: 0 = no drift, 1 = complete drift */
+    overallScore: number;
+    /** Ghost lexicon decay: percentage of domain words that disappeared */
+    lexiconDecay: number;
+    /** Tool-call Jaccard distance: 0 = identical patterns, 1 = completely different */
+    toolShift: number;
+    /** Keyword overlap decline: percentage of shared keywords lost */
+    semanticDrift: number;
+    /** Domain words that disappeared */
+    lostWords: string[];
+    /** New tool calls that weren't in the baseline */
+    newTools: string[];
+    /** Missing tool calls that were in the baseline */
+    missingTools: string[];
+}
+
+interface MemoryFact {
+    id: string;
+    agentId: string;
+    category: "fact" | "secret" | "preference" | "commitment" | "task-state";
+    content: string;
+    keywords: string[];
+    source: {
+        channel: string;
+        chatId: string;
+        sender: string;
+        date: string;
+    };
+    createdAt: string;
+    expiresAt?: string;
+    accessCount?: number;
+    lastAccessed?: string;
+    nextReview?: string;
+    /** Review interval in days — doubles on each successful recall */
+    intervalDays?: number;
+}
+declare class MemoryStore {
+    private memoryDir;
+    constructor(baseDir?: string);
+    private filePath;
+    addMemory(agentId: string, fact: Omit<MemoryFact, "id" | "createdAt">): void;
+    getAll(agentId: string): MemoryFact[];
+    findRelevant(message: string, agentId: string, limit?: number): MemoryFact[];
+    buildContext(memories: MemoryFact[]): string;
+    /**
+     * Record that memories were accessed (for spaced repetition tracking).
+     */
+    recordAccess(agentId: string, memoryIds: string[]): void;
+    /**
+     * Get memories due for review (spaced repetition).
+     * Returns facts whose nextReview date has passed or that have never been reviewed.
+     */
+    getDueForReview(agentId: string, limit?: number): MemoryFact[];
+    /**
+     * Build a recall prompt for memories due for review.
+     * Injected into heartbeat context so the agent proactively recalls facts.
+     */
+    buildRecallContext(agentId: string): string;
+    /**
+     * Check if a substantially similar memory already exists.
+     */
+    hasSimilar(agentId: string, content: string): boolean;
+    /**
+     * Prune old/expired memories. Cap at MAX_MEMORIES per agent.
+     */
+    prune(agentId: string): void;
+}
+
+/**
+ * Verified channel context — facts the channel adapter knows for certain.
+ * Prevents agents from hallucinating about their environment.
+ */
+interface ChannelMeta {
+    /** Channel name */
+    channel: string;
+    /** Verified agents/bots present in this chat/group/project */
+    agents?: Array<{
+        id: string;
+        name: string;
+        handle?: string;
+    }>;
+    /** Project path (GitLab) or group topic */
+    project?: string;
+    /** Issue/MR context (GitLab) */
+    issue?: {
+        type: string;
+        iid: string;
+        title: string;
+    };
+    /** Channel-specific facts (e.g., pipeline status, group description) */
+    facts?: string[];
+}
+interface IncomingMessage {
+    id: string;
+    channel: string;
+    accountId: string;
+    sender: {
+        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;
+        name: string;
+    };
+    text: string;
+    replyTo?: string;
+    replyToText?: string;
+    timestamp: Date;
+    media?: {
+        path: string;
+        type: string;
+        fileName?: string;
+    };
+    raw?: unknown;
+    resolvedAgent?: string;
+    preferNode?: string;
+    channelMeta?: ChannelMeta;
+    /** Correlator threaded by the workflow engine. When a workflow dispatches
+     *  an agent, this carries the run id through the pipeline so post:response
+     *  can re-enter the engine with `kind: agentResult` transitions. Opaque
+     *  everywhere outside src/workflows/. */
+    workflowRunId?: string;
+    /** Phase 1 / 6 — when set, identifies the intent-ledger decision row
+     *  this message corresponds to. The agent registry calls
+     *  `ledger.recordResolution(...)` when the dispatched task completes,
+     *  so Inv-ActiveTaskSafety's "decision in flight" check can clear.
+     *  Set by the channel adapter (gitlab, router) right after
+     *  recordGitLabTargetDispatch / recordRouterDispatch returns the
+     *  decision row. Undefined when the dispatch was deduped/halted by
+     *  the ledger (no resolution to write) or when the source is in
+     *  mode=off. */
+    intentRef?: {
+        eventId: string;
+        decidedBy: string;
+    };
+}
+interface OutgoingMessage {
+    channel: string;
+    chatId: string;
+    text: string;
+    replyTo?: string;
+    parseMode?: "markdown" | "html" | "plain";
+    agentId?: string;
+    poll?: {
+        name: string;
+        values: string[];
+        selectableCount?: number;
+    };
+    media?: {
+        type: "image" | "document" | "audio" | "video";
+        url: string;
+        caption?: string;
+        mimetype?: string;
+        fileName?: string;
+    };
+}
+interface ChannelAdapter {
+    readonly name: string;
+    /** Start polling or webhook listener */
+    start(): Promise<void>;
+    /** Stop the adapter gracefully */
+    stop(): Promise<void>;
+    /** Send a message back to a chat */
+    send(msg: OutgoingMessage): Promise<string | void>;
+    /** Edit an existing message (returns false if not supported) */
+    editMessage?(chatId: string, messageId: string, text: string, parseMode?: string): Promise<boolean>;
+    /** Send typing/action indicator */
+    sendTyping?(chatId: string): Promise<void>;
+    /** React to a message with an emoji (e.g., 👀 for seen) */
+    react?(chatId: string, messageId: string, emoji?: string): Promise<void>;
+    /** Register handler for incoming messages */
+    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
+    /** Get verified context for a chat (optional — channels implement what they can) */
+    getChannelMeta?(chatId: string): Promise<ChannelMeta | undefined>;
+    /** Fetch the most recent messages from the live channel for cold-start
+     *  session seeding. Called once per (agent, channel, chatId, day) when a
+     *  fresh session is created — never on warm cache hits. Bounded by
+     *  maxMessages and maxChars (enforced by the caller). Channels return their
+     *  own externalId so SessionStore can dedup against re-seeds. */
+    seedHistory?(chatId: string, opts: {
+        sinceISO?: string;
+        maxMessages: number;
+        maxChars: number;
+    }): Promise<Array<SeededMessage>>;
+}
+/** A message returned by seedHistory — flat, channel-agnostic. */
+interface SeededMessage {
+    role: "user" | "agent";
+    name: string;
+    content: string;
+    timestamp: string;
+    externalId?: string;
+    /** Optional channel-side account/bot identity that handled this message
+     *  (e.g., Telegram accountId "noqta_cx_bot"). Captured by adapters that
+     *  shadow-log outbound, so seeded history preserves the audit trail of
+     *  which bot identity actually sent each line. Renderers may ignore it. */
+    accountId?: string;
+}
+
+interface SessionMessage {
+    role: "user" | "agent";
+    name?: string;
+    content: string;
+    timestamp: string;
+    /** True when this message was injected by SessionStore.seedFromAdapter()
+     *  reading the live channel on cold session create — never via the inbound
+     *  router pipeline. Marked so observers can distinguish seeded turns from
+     *  live ones; the model sees them identically in buildHistoryContext. */
+    seeded?: boolean;
+    /** Channel-side message id (Telegram update_id, GitLab note id, WhatsApp
+     *  key.id). Used to dedup re-seeds — if a message with this externalId is
+     *  already in the session, appendSeededMessages skips it. */
+    externalId?: string;
+}
+interface Session {
+    id: string;
+    agentId: string;
+    channel: string;
+    chatId: string;
+    day: string;
+    claudeSessionId?: string;
+    messages: SessionMessage[];
+    createdAt: string;
+    updatedAt: string;
+    /** Number of completed turns on the current claudeSessionId. Resets to 0
+     *  when the session is rotated (cleared). Used to bound --resume growth:
+     *  Claude CLI replays the entire prior session on every turn, so long
+     *  sessions pay a linearly growing cache-read tax. */
+    turnCount?: number;
+    /** Total billable input of the LAST turn on this claudeSessionId
+     *  (inputTokens + cacheReadTokens + cacheCreateTokens). Used to detect
+     *  tier-2 hits (>200K) from the prior turn so we can rotate before the
+     *  next turn pays the 1.5× multiplier again. */
+    lastTurnInputTokens?: number;
+}
+declare class SessionStore {
+    private sessionsDir;
+    private cache;
+    private staleMinutes;
+    private maxTurnsPerSession;
+    private tierTwoThresholdTokens;
+    /** Resolves a channel name to its adapter — installed by the daemon after
+     *  channels are registered (see daemon/index.ts after router.register). The
+     *  cold-create branch consults it to call adapter.seedHistory(). Optional;
+     *  when unset, seeding is a no-op (back-compat for tests, CLI tools, and
+     *  any caller that constructs SessionStore standalone). */
+    private adapterResolver?;
+    /** In-flight seed promises keyed by sessionKey. Coalesces concurrent
+     *  cold-creates against the same (agent, channel, chatId, day) so we hit
+     *  the channel API exactly once per fresh session. */
+    private seedingPromises;
+    constructor(baseDir?: string, opts?: {
+        staleMinutes?: number;
+        maxTurnsPerSession?: number;
+        tierTwoThresholdTokens?: number;
+    });
+    /** Install the channel-adapter resolver. Called once at daemon startup
+     *  after MessageRouter has registered every adapter. Hot-reload of channel
+     *  adapters re-uses the same router, so the resolver stays valid across
+     *  /reload cycles without re-installation. */
+    setAdapterResolver(fn: (channel: string) => ChannelAdapter | undefined): void;
+    /** Seed a fresh session from the live channel before any user/agent
+     *  messages get appended. No-op when:
+     *    - the session already has messages (warm cache or partially loaded)
+     *    - no adapter resolver is installed
+     *    - the channel adapter has no seedHistory method
+     *  Concurrent calls against the same key share one in-flight promise so
+     *  the channel API is hit exactly once per cold create. Errors are
+     *  swallowed — a seeding failure should never block a turn. */
+    seedIfEmpty(agentId: string, channel: string, chatId: string): Promise<void>;
+    /** Append seeded messages to a session in chronological order, deduping
+     *  by externalId against anything already present. Marks each entry with
+     *  `seeded: true` so observers can distinguish them; the model's prompt
+     *  (buildHistoryContext) renders them identically to live turns. */
+    private appendSeededMessages;
+    /**
+     * Build a deterministic session key.
+     */
+    private sessionKey;
+    private sessionFile;
+    /**
+     * Get or create a session for this agent+channel+chat+day.
+     */
+    getSession(agentId: string, channel: string, chatId: string): Session;
+    /**
+     * Add a user message to the session. Consecutive duplicates from the same
+     * sender are collapsed — when a user re-sends the exact same text (retry,
+     * accidental double-tap, telegram glitches), storing every copy bloats the
+     * replayed history and re-burns tokens on every subsequent turn.
+     */
+    addUserMessage(agentId: string, channel: string, chatId: string, senderName: string, content: string): void;
+    /**
+     * Add an agent response to the session. Same dedup rule as user messages —
+     * retries and duplicate responses shouldn't be replayed on every turn.
+     */
+    addAgentMessage(agentId: string, channel: string, chatId: string, content: string): void;
+    /**
+     * Get the Claude Code session ID for this conversation (for --resume).
+     * Returns undefined if no session yet (first message of the day).
+     */
+    getClaudeSessionId(agentId: string, channel: string, chatId: string): string | undefined;
+    /**
+     * Store the Claude Code session ID after first invocation.
+     */
+    setClaudeSessionId(agentId: string, channel: string, chatId: string, claudeSessionId: string): void;
+    /**
+     * Build conversation history string to prepend to the prompt.
+     * Returns empty string if no history.
+     * Used for non-claude-code tiers that don't have native sessions.
+     */
+    buildHistoryContext(agentId: string, channel: string, chatId: string): string;
+    /**
+     * Recall conversation turns across multiple stored sessions for an agent.
+     *
+     * Used by the `/recall` HTTP endpoint and the [Conversation Recall] skill —
+     * when an agent receives a message that references prior context (anaphora,
+     * "as discussed", "correct me if I'm wrong"), it can call this to fetch
+     * the actual prior turns rather than guessing or running cold-start tool
+     * calls. Read-only; no side effects.
+     *
+     * Pagination: cursor by timestamp, descending (newest first). Pass the
+     * previous response's `oldestTs` as `before` to walk further back.
+     *
+     * Scoping: required `agentId`. `channel`/`chatId` narrow to a specific
+     * thread; omit them to recall across all of this agent's conversations.
+     * The store is per-agent on disk so we never leak another agent's chats.
+     */
+    recallTurns(opts: {
+        agentId: string;
+        channel?: string;
+        chatId?: string;
+        before?: string;
+        after?: string;
+        /** Convenience override for `after`: number of days back from now. */
+        lookbackDays?: number;
+        limit?: number;
+        query?: string;
+        participants?: string[];
+    }): {
+        turns: Array<{
+            ts: string;
+            role: "user" | "agent";
+            senderName: string;
+            content: string;
+            channel: string;
+            chatId: string;
+            day: string;
+            sessionFile: string;
+        }>;
+        oldestTs: string | null;
+        hasMore: boolean;
+        totalScanned: number;
+    };
+    /** Cross-agent view of a chat. Aggregates session messages from EVERY
+     *  agent that has a session for `(channel, chatId)` in the requested
+     *  window, sorts oldest-first, and dedups exact (timestamp, role, name,
+     *  content) collisions (which happen when two agents in the same group
+     *  both record the same inbound).
+     *
+     *  Differs from recallTurns in two ways:
+     *    1. Not scoped to one agentId — answers "what's in this chat across
+     *       all agents", which is the question the cx→devops→marketing thread
+     *       on 2026-04-29 needed and didn't have.
+     *    2. Returns oldest-first so the caller reads it like a transcript;
+     *       recallTurns returns newest-first because it paginates.
+     *
+     *  Bounded by the same MAX_MESSAGES default as buildHistoryContext so
+     *  callers don't accidentally pull a 5000-turn group into one prompt. */
+    recentByChatId(opts: {
+        channel: string;
+        chatId: string;
+        sinceISO?: string;
+        limit?: number;
+    }): Array<{
+        ts: string;
+        role: "user" | "agent";
+        senderName: string;
+        content: string;
+        agentId: string;
+        sessionFile: string;
+    }>;
+    /**
+     * Check if a Claude session is stale (idle too long for --resume to be useful).
+     * When stale, the resumed context will be too far behind — better to start fresh.
+     */
+    isSessionStale(agentId: string, channel: string, chatId: string): boolean;
+    /**
+     * Build a summary of recent messages from OTHER sessions for the same agent today.
+     * This bridges the cross-chat amnesia gap — if someone shared info in a DM,
+     * the group session gets a hint about it.
+     *
+     * Gated by `message`: cross-chat hints are expensive (up to ~1.5K tokens of
+     * unrelated conversation) AND cache-breaking (the content changes as other
+     * chats get traffic, invalidating the prompt cache every turn). We only
+     * return hints when the current message actually references another
+     * conversation or a peer agent. Pass `message = ""` to force-include
+     * (legacy behavior) — useful for testing.
+     */
+    getCrossSessionSummary(agentId: string, channel: string, chatId: string, message?: string): string;
+    /**
+     * Check if session history needs compaction and compact if so.
+     * Call this after adding messages. Returns true if compaction was performed.
+     */
+    compactIfNeeded(agentId: string, channel: string, chatId: string, memoryStore?: MemoryStore): Promise<{
+        compacted: boolean;
+        qualityScore?: number;
+        lostEntities?: string[];
+        drift?: DriftReport;
+    }>;
+    /**
+     * Check if current session already has a compacted summary.
+     */
+    hasCompaction(agentId: string, channel: string, chatId: string): boolean;
+    /**
+     * Clear the stored Claude session ID so next invocation starts fresh.
+     * Also resets the per-session turn counter and last-turn input size —
+     * those are only meaningful relative to the current claudeSessionId.
+     */
+    clearClaudeSessionId(agentId: string, channel: string, chatId: string): void;
+    /**
+     * Check whether this session has hit the max-turns cap. Rotate when true
+     * to stop --resume replay from growing unbounded across a long chat.
+     */
+    shouldRotateByTurns(agentId: string, channel: string, chatId: string): boolean;
+    /**
+     * Check whether the LAST turn on this session pushed total input past
+     * the tier-2 threshold. If yes, rotate so we don't pay the 1.5×
+     * multiplier again on the next turn.
+     */
+    shouldRotateByTierTwo(agentId: string, channel: string, chatId: string): boolean;
+    /**
+     * Record a completed turn's token usage and bump the turn counter.
+     * Called after a successful Claude response returns with usage info.
+     */
+    recordTurnUsage(agentId: string, channel: string, chatId: string, usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens: number;
+        cacheCreateTokens: number;
+    }): void;
+    /** Diagnostic getters — used by registry logging. */
+    getTurnCount(agentId: string, channel: string, chatId: string): number;
+    getLastTurnInputTokens(agentId: string, channel: string, chatId: string): number;
+    getMaxTurnsPerSession(): number;
+    getTierTwoThresholdTokens(): number;
+    /**
+     * Trim session to stay within limits.
+     */
+    private trim;
+    private save;
+}
+
 type WikiAccess = "private" | "shared" | "public";
 /**
  * Article type — the organizational spine. Matches Farzapedia's
@@ -5143,11 +6060,29 @@ declare const indexFileSchema: z.ZodObject<{
 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.
+ * Ships with the install. When .agentx/graph/schema.json is missing,
+ * the store seeds this so a fresh daemon has something to classify
+ * against.
+ *
+ * v2 — Phase 1 of the classifier-retire plan: verb-level intent
+ * taxonomy. The classifier now answers ONLY "what kind of work is
+ * this" — it does not embed client/project/agent in the leaf because
+ * those already live on the event metadata (project, subject,
+ * agentId). One copy of "review.merge-request" instead of one per
+ * client.
  *
- * Five levels, three primaries at the leaf (who / what / where) — matches
- * the "primary colors per level" design from the plan.
+ * Two levels:
+ *   category — broad work area (code/ops/support/admin/knowledge/social/system)
+ *   verb     — specific intent (review.merge-request, deploy.staging, etc.)
+ *
+ * The category is closed-set; the verb is open-set so the operator
+ * can add new ones via `agentx graph review` over time. Most paths
+ * will reuse the seeded verbs below.
+ *
+ * Why so few levels: every level is information the classifier
+ * actually has to decide. The previous v1 schema (scope > location >
+ * org > unit > activity) re-encoded data already on the event —
+ * forcing a 5-LLM-question prompt to recover what we already knew.
  */
 declare const STARTER_SCHEMA: GraphSchema;
 
@@ -5163,7 +6098,13 @@ declare class GraphStore {
     nodesPath(): string;
     indexPath(): string;
     classificationsPath(): string;
-    /** Load the graph schema, seeding STARTER_SCHEMA if the file is missing. */
+    /** Load the graph schema, seeding STARTER_SCHEMA if the file is missing.
+     *  Phase 1 of the classifier-retire plan ships a v2 verb-level schema;
+     *  installs with the v1 hierarchical schema (scope > org > unit >
+     *  activity) get auto-migrated on next load: the v1 file is renamed
+     *  to schema.v1.bak.json, the v2 starter is written, and the
+     *  per-event nodes.json + classifications.jsonl are left alone for
+     *  historical reading. New events classify under v2 from then on. */
     loadSchema(): GraphSchema;
     saveSchema(schema: GraphSchema): void;
     loadNodes(): NodesFile;
@@ -5239,6 +6180,65 @@ declare class GraphStore {
     rejectClassification(c: Classification): void;
 }
 
+type MemoryType = "user" | "feedback" | "project" | "reference";
+interface MemoryRecord {
+    /** Slug-safe name, unique within an agent. */
+    name: string;
+    type: MemoryType;
+    /** One-line hook — used as the MEMORY.md index entry. */
+    description: string;
+    /** The body, excluding frontmatter. */
+    body: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface AgentMemoryOptions {
+    baseDir?: string;
+}
+declare class AgentMemory {
+    readonly baseDir: string;
+    constructor(opts?: AgentMemoryOptions);
+    private dirFor;
+    private fileFor;
+    private indexPath;
+    /** Save (create or update) a memory. Keeps createdAt stable across
+     *  updates; bumps updatedAt. Always rewrites MEMORY.md. */
+    save(args: {
+        agentId: string;
+        type: MemoryType;
+        name: string;
+        description: string;
+        body: string;
+    }): MemoryRecord;
+    get(agentId: string, name: string): MemoryRecord | null;
+    /** Every memory for an agent. Sorted by type then name for stable
+     *  index rendering. */
+    list(agentId: string): MemoryRecord[];
+    /** Remove a memory by name. Returns true on success, false if none found. */
+    remove(agentId: string, name: string): boolean;
+    /** The content of MEMORY.md — used at prompt-build time to inline into
+     *  the agent's system prompt. Returns "" when the agent has no
+     *  memories (so the prompt builder can no-op). */
+    indexMarkdown(agentId: string): string;
+    /** Push the agent's memory into its workspace so Claude Code sessions
+     *  pick it up automatically. Does two things:
+     *
+     *  1. Writes `<workspace>/.agentx-memory.md` — full MEMORY.md content,
+     *     explicit file the skill can `Read` at session start.
+     *  2. Merges that same content into `<workspace>/CLAUDE.md` between
+     *     sentinel comments so Claude Code auto-loads it into the cached
+     *     system context on every session. Idempotent: subsequent syncs
+     *     replace the sentinel block.
+     *
+     *  Never touches content outside the sentinel block — if the file
+     *  doesn't exist, creates it with just the sentinels. Safe to call
+     *  on any save / delete. */
+    syncToWorkspace(agentId: string, workspacePath: string): void;
+    /** Regenerate MEMORY.md from the on-disk files. Called automatically
+     *  after every save / remove; safe to call manually. */
+    rewriteIndex(agentId: string): void;
+}
+
 interface MeshPeerInfo {
     peer: string;
     healthy: boolean;
@@ -5331,6 +6331,12 @@ declare class AgentRegistry {
     private sessions;
     private wikiHub;
     private memoryStore;
+    /** Structured per-agent memory (Claude-Code-style: user / feedback /
+     *  project / reference). Separate from the BM25 fact store above —
+     *  that's for short-lived facts extracted from conversations; this is
+     *  for long-lived behavioural memory that inlines into the system
+     *  prompt on every task. */
+    readonly agentMemory: AgentMemory;
     private patternStore;
     private rateLimiter;
     private tokenTracker;
@@ -5353,6 +6359,11 @@ declare class AgentRegistry {
     private lastSummaries;
     /** 24-hour sparkline cache per agent — recomputed from disk at most once a minute. */
     private sparklineCache;
+    /** Per-workspace references registry cache. Loaded lazily on first turn for
+     *  agents with `contextReferences: true`; reused for the daemon's lifetime
+     *  (operator-edited registries take effect on next daemon restart — same
+     *  policy as agentx.json). */
+    private referencesCache;
     private log;
     constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
     /**
@@ -5406,6 +6417,21 @@ declare class AgentRegistry {
     /** Wiki hub accessor. */
     getWikiHub(): WikiHub;
     getGraphStore(): GraphStore | undefined;
+    /** Session-store accessor — used by the /recall HTTP endpoint to expose
+     *  conversation history to agents that need to rebuild context. */
+    getSessionStore(): SessionStore;
+    /** Fire-and-forget pre-rotation memo capture. Spawns a one-shot Haiku
+     *  call against the about-to-be-dropped Claude session asking for the
+     *  facts/decisions worth carrying forward, persists the result into
+     *  MemoryStore. Runs asynchronously so the calling rotation path
+     *  doesn't pay the extraction latency — the next user turn dispatches
+     *  immediately on the fresh session, and the memo lands in time for
+     *  whichever turn arrives ~30s later (which is when atlas's bloated-
+     *  session WhatsApp conversations actually need it).
+     *
+     *  Errors are swallowed by design — memory continuity is best-effort,
+     *  it must never block or break the rotation it's hooked into. */
+    private captureRotationMemoAsync;
     /**
      * Build peer list for context engine.
      */
@@ -5416,11 +6442,27 @@ declare class AgentRegistry {
     private getChannelHandle;
     /**
      * Execute a task on an agent. Respects maxConcurrent limit.
+     *
+     * Wraps `executeInternal` to record an intent-ledger resolution
+     * after completion when `task.intentRef` is set. The resolution
+     * write clears the dispatched-but-unresolved slot in
+     * `intent_decisions` so Inv-ActiveTaskSafety lookups stop blocking
+     * subsequent dispatches to the same (project, subject). Without
+     * this, every dispatched decision sits in-flight forever and the
+     * active-task check becomes vacuously over-aggressive.
      */
     execute(task: AgentTask, onDelta?: StreamCallback): Promise<AgentResponse>;
+    /**
+     * Internal dispatcher — the real body. See `execute` for the public
+     * wrapper that adds intent-ledger resolution recording.
+     */
+    private executeInternal;
     /**
      * List all agents and their status.
      */
+    /** Total active task count across all agents — used by the daemon's
+     *  graceful shutdown to drain in-flight runs before exit. */
+    getActiveTaskCount(): number;
     list(): Array<{
         id: string;
         name: string;
@@ -5525,94 +6567,6 @@ declare class AgentRegistry {
     getTokenTracker(): TokenTracker;
 }
 
-/**
- * Verified channel context — facts the channel adapter knows for certain.
- * Prevents agents from hallucinating about their environment.
- */
-interface ChannelMeta {
-    /** Channel name */
-    channel: string;
-    /** Verified agents/bots present in this chat/group/project */
-    agents?: Array<{
-        id: string;
-        name: string;
-        handle?: string;
-    }>;
-    /** Project path (GitLab) or group topic */
-    project?: string;
-    /** Issue/MR context (GitLab) */
-    issue?: {
-        type: string;
-        iid: string;
-        title: string;
-    };
-    /** Channel-specific facts (e.g., pipeline status, group description) */
-    facts?: string[];
-}
-interface IncomingMessage {
-    id: string;
-    channel: string;
-    accountId: string;
-    sender: {
-        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;
-        name: string;
-    };
-    text: string;
-    replyTo?: string;
-    replyToText?: string;
-    timestamp: Date;
-    media?: {
-        path: string;
-        type: string;
-        fileName?: string;
-    };
-    raw?: unknown;
-    resolvedAgent?: string;
-    preferNode?: string;
-    channelMeta?: ChannelMeta;
-    /** Correlator threaded by the workflow engine. When a workflow dispatches
-     *  an agent, this carries the run id through the pipeline so post:response
-     *  can re-enter the engine with `kind: agentResult` transitions. Opaque
-     *  everywhere outside src/workflows/. */
-    workflowRunId?: string;
-}
-interface OutgoingMessage {
-    channel: string;
-    chatId: string;
-    text: string;
-    replyTo?: string;
-    parseMode?: "markdown" | "html" | "plain";
-    agentId?: string;
-}
-interface ChannelAdapter {
-    readonly name: string;
-    /** Start polling or webhook listener */
-    start(): Promise<void>;
-    /** Stop the adapter gracefully */
-    stop(): Promise<void>;
-    /** Send a message back to a chat */
-    send(msg: OutgoingMessage): Promise<string | void>;
-    /** Edit an existing message (returns false if not supported) */
-    editMessage?(chatId: string, messageId: string, text: string, parseMode?: string): Promise<boolean>;
-    /** Send typing/action indicator */
-    sendTyping?(chatId: string): Promise<void>;
-    /** React to a message with an emoji (e.g., 👀 for seen) */
-    react?(chatId: string, messageId: string, emoji?: string): Promise<void>;
-    /** Register handler for incoming messages */
-    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;
-    /** Get verified context for a chat (optional — channels implement what they can) */
-    getChannelMeta?(chatId: string): Promise<ChannelMeta | undefined>;
-}
-
 interface HandoverOverride {
     channel: string;
     chatId: string;
@@ -5935,12 +6889,76 @@ declare const businessConfigSchema: z.ZodObject<{
         reportsTo?: string | undefined;
         utilizationTarget?: number | undefined;
     }>>>;
+    /** Per-project metadata. Phase 3 — defaults to empty array, so
+     *  existing agentx.json files validate without modification. */
+    projects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Project identifier. For GitLab/GitHub: "owner/repo". For
+         *  noqta-internal projects: a stable string. */
+        id: z.ZodString;
+        /** AgentId of the PM for this project. Looked up by
+         *  `Organization.pmFor(project)` at dispatch time. */
+        pm: z.ZodOptional<z.ZodString>;
+        /** Optional client this project belongs to. Used by the activity
+         *  graph to attribute non-projected events (Telegram chats, free-
+         *  text WhatsApp, cron jobs) to the right client. Falls back to
+         *  the leading segment of `id` (split on "/") when unset. */
+        client: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        pm?: string | undefined;
+        client?: string | undefined;
+    }, {
+        id: string;
+        pm?: string | undefined;
+        client?: string | undefined;
+    }>, "many">>;
+    /** Maps free-text chat senders to a client/project so the activity
+     *  graph can attribute Telegram/WhatsApp/etc. to the right client
+     *  instead of the catch-all "internal" bucket. */
+    contactMap: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Channel kind, e.g. "telegram", "whatsapp", "slack", "discord". */
+        channel: z.ZodOptional<z.ZodString>;
+        /** Native chat id ("-100..." for tg groups, JID for WhatsApp). */
+        chatId: z.ZodOptional<z.ZodString>;
+        /** Sender username/handle as exposed by the channel adapter. */
+        username: z.ZodOptional<z.ZodString>;
+        /** Numeric sender id when username is unstable. */
+        senderId: z.ZodOptional<z.ZodString>;
+        /** Client this contact belongs to. Required. */
+        client: z.ZodString;
+        /** Project this contact's traffic should attribute to. Defaults to
+         *  `${client}/_chat`. */
+        project: z.ZodOptional<z.ZodString>;
+        /** Display name override for the initiator pill. */
+        displayName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        client: string;
+        channel?: string | undefined;
+        chatId?: string | undefined;
+        username?: string | undefined;
+        senderId?: string | undefined;
+        project?: string | undefined;
+        displayName?: string | undefined;
+    }, {
+        client: string;
+        channel?: string | undefined;
+        chatId?: string | undefined;
+        username?: string | undefined;
+        senderId?: string | undefined;
+        project?: string | undefined;
+        displayName?: string | undefined;
+    }>, "many">>;
     /** 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;
+    projects: {
+        id: string;
+        pm?: string | undefined;
+        client?: string | undefined;
+    }[];
     timezone: string;
     mainChannel: {
         channel: string;
@@ -5978,6 +6996,15 @@ declare const businessConfigSchema: z.ZodObject<{
         utilizationTarget: number;
         reportsTo?: string | undefined;
     }>;
+    contactMap: {
+        client: string;
+        channel?: string | undefined;
+        chatId?: string | undefined;
+        username?: string | undefined;
+        senderId?: string | undefined;
+        project?: string | undefined;
+        displayName?: string | undefined;
+    }[];
     workTickMinutes: number;
     idleQueueThreshold: number;
 }, {
@@ -5998,6 +7025,11 @@ declare const businessConfigSchema: z.ZodObject<{
         glob?: string | undefined;
     };
     enabled?: boolean | undefined;
+    projects?: {
+        id: string;
+        pm?: string | undefined;
+        client?: string | undefined;
+    }[] | undefined;
     timezone?: string | undefined;
     roles?: Record<string, {
         title: string;
@@ -6019,6 +7051,15 @@ declare const businessConfigSchema: z.ZodObject<{
         reportsTo?: string | undefined;
         utilizationTarget?: number | undefined;
     }> | undefined;
+    contactMap?: {
+        client: string;
+        channel?: string | undefined;
+        chatId?: string | undefined;
+        username?: string | undefined;
+        senderId?: string | undefined;
+        project?: string | undefined;
+        displayName?: string | undefined;
+    }[] | undefined;
     workTickMinutes?: number | undefined;
     idleQueueThreshold?: number | undefined;
 }>;
@@ -6036,6 +7077,7 @@ interface EmployeeProfile {
 }
 declare class Organization {
     private employees;
+    private projects;
     constructor(config: BusinessConfig);
     get(agentId: string): EmployeeProfile | undefined;
     all(): EmployeeProfile[];
@@ -6043,6 +7085,43 @@ declare class Organization {
     directReports(agentId: string): string[];
     /** Walk up the org tree to the root. First element is `agentId` itself. */
     chainOfCommand(agentId: string): string[];
+    /**
+     * Phase 3 — PM lookup. Returns the agentId of the PM responsible
+     * for `project`, or `undefined` when no PM is configured. The
+     * dispatcher's PM gate (in a future commit) calls this before
+     * dispatching to make sure project-scoped events flow through the
+     * PM first. When undefined, dispatches proceed without a PM gate
+     * (the legacy direct-routing behavior).
+     */
+    pmFor(project: string | null | undefined): string | undefined;
+    /**
+     * Phase 3 — escalation chain. Returns agents to escalate to in
+     * upward order, EXCLUDING the agent itself. `chainOfCommand`
+     * includes self at index 0; escalationChain skips that.
+     *
+     * Used when an agent fails / declines / times out — the dispatcher
+     * walks up the chain looking for someone to take over.
+     */
+    escalationChain(agentId: string): string[];
+    /**
+     * Phase 3 — capability check (scaffold). Returns true when:
+     *   - The org chart is empty (`employees.size === 0`) — this is the
+     *     permissive default for partially-configured `business` blocks
+     *     that populate `projects[].pm` for the PM gate but haven't
+     *     filled in `orgChart`. Without this fallback, enabling business
+     *     with an empty orgChart would block every dispatch.
+     *   - OR the agent is registered in the org chart.
+     *
+     * Per-project / per-intent restrictions need typed capabilities
+     * (Phase 5); until then this is a permissive-when-unconfigured
+     * default that matches the legacy any-registered-agent-can-handle-
+     * anything behavior.
+     *
+     * The `decideAndCommit` PM gate will call this *after* the PM
+     * approves — the PM provides the project-scoped check, this
+     * provides the agent-existence check.
+     */
+    canHandle(agentId: string, _project: string | null | undefined, _intent: string | null | undefined): boolean;
 }
 
 declare class Schedule {
@@ -6065,8 +7144,11 @@ interface WorkItem {
     estimatedSeconds?: number;
     url?: string;
     priority?: number;
-    /** Board stage derived from labels (kanban column id). */
-    stage?: "triage" | "todo" | "doing" | "onhold" | "review" | "done";
+    /** Board stage / kanban column id. Was a closed enum back when boards
+     *  had a fixed schema; widened to `string` because per-project boards
+     *  can declare arbitrary column ids. The well-known names below remain
+     *  the standard set most boards use. */
+    stage?: string;
     /** 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). */
@@ -6289,6 +7371,13 @@ declare class MessageRouter {
     private dedupSaveTimer?;
     /** Crash-safe inflight log (see InflightLog class above). */
     private inflight;
+    /** In-flight mesh forwards (this node is awaiting a peer's response).
+     *  Counted so the daemon's shutdown drain can wait for these in addition
+     *  to local agent tasks — otherwise a clawd restart mid-forward kills the
+     *  awaiter, the peer's response lands on a dead connection, and the
+     *  inflight-replay re-runs the task on the peer. */
+    private activeMeshForwards;
+    getActiveMeshForwardCount(): number;
     constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
     private loadDedupFromDisk;
     private scheduleDedupSave;
@@ -6335,6 +7424,23 @@ declare class MessageRouter {
      * Stamps the key when false. Size-bounded GC avoids unbounded growth.
      */
     private isDuplicateMessage;
+    /**
+     * Phase 1 commit 6.b — record one router decision in the intent ledger
+     * when the source is enabled (mode != "off"). Covers all router
+     * channels (telegram, slack, whatsapp, discord). Each channel has its
+     * own per-source mode flag so they can be promoted independently in 1c.
+     * Wrapped in try/catch so a ledger failure can never break message
+     * routing — legacy is still authoritative until the 1c per-source
+     * promotion.
+     *
+     * Returns the recorded decision when ledger fired (and outcome was
+     * "dispatched"), so the caller can tag the IncomingMessage with
+     * `intentRef` for resolution-on-completion. Returns undefined when
+     * the source is off, the channel isn't supported, ledger threw, or
+     * the ledger's own decision was non-dispatched (deduped/halted —
+     * no resolution to write).
+     */
+    private recordRouterDecisionInLedger;
     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. */
@@ -6352,10 +7458,21 @@ declare class MessageRouter {
     private adapterEdit;
     private adapterReact;
     private startTypingLoop;
+    private traceRoute;
+    private runRoutingPipeline;
     /**
      * Handle a message by routing to a mesh peer's agent.
      * Searches peer agent cards for mention matches.
      */
+    /** Build the context payload that mesh.sendTask forwards to the receiving
+     *  daemon's /task handler. Without this, the receiver runs registry.execute
+     *  with default channel="api"/chatId="default" — losing the channel,
+     *  project, issue id, sender, and channelMeta the original adapter built
+     *  from the inbound webhook. Shape matches what processResolvedMessage
+     *  already passes to registry.execute on the local path, so a mesh-routed
+     *  task and a locally-routed task produce the same session keying and
+     *  the same prompt context. */
+    private buildMeshContext;
     private handleViaMesh;
     /**
      * Route to a mesh peer by resolved agentId (not text matching).
@@ -6368,6 +7485,10 @@ declare class MessageRouter {
      */
     private handleViaMeshByPeer;
     private getAccountForAgent;
+    /** @deprecated Phase 2 — resolveAgent now delegates to the pipeline.
+     *  Kept as a thin wrapper for callers that only need the agentId; new
+     *  code should call runRoutingPipeline() to get the full PipelineResult
+     *  (deciding stage, drop reason, per-stage trace). */
     private resolveAgent;
 }
 
@@ -6381,7 +7502,7 @@ interface TelegramAccountConfig {
 declare class TelegramAdapter implements ChannelAdapter {
     readonly name = "telegram";
     private accounts;
-    private offsetStore;
+    private cursors;
     private handler?;
     private polling;
     /** Per-account polling gate — flipped to false when an account is removed
@@ -6449,6 +7570,12 @@ declare class TelegramAdapter implements ChannelAdapter {
     private chatAccountMap;
     private botInfo;
     private groupStore;
+    /** Account IDs of bots currently active (member/administrator) in a group.
+     *  Used by the router to pick the correct bot when an agent has multiple
+     *  Telegram accounts bound to it (e.g. pm-ksi → both @noqta_ksi_bot and
+     *  @noqta_pm_ksi_bot) — the in-group account should win, otherwise messages
+     *  to the absent bot get silently dropped by multi-account-dedup. */
+    getGroupBotAccounts(groupId: string): string[];
     /**
      * Send a message. Returns the sent message ID.
      * Pass accountId to send from a specific bot account.
@@ -6456,6 +7583,12 @@ declare class TelegramAdapter implements ChannelAdapter {
     send(msg: OutgoingMessage & {
         accountId?: string;
     }): Promise<string>;
+    /** Best-effort outbound shadow log. Captures every successful send into
+     *  the same per-chat shadow file the inbound writer uses, so seedHistory
+     *  + agent introspection see a complete picture (which bot identity sent
+     *  what, at which time). Failures are swallowed — the message already
+     *  went out on the wire; logging is observability, not correctness. */
+    private recordOutboundShadow;
     /**
      * Send a message with an inline keyboard. Used by the workflow user-task
      * renderer so approve/reject-style tasks get one-tap URL buttons in
@@ -6527,6 +7660,26 @@ declare class TelegramAdapter implements ChannelAdapter {
      * Called once per group on first encounter, then maintained via my_chat_member events.
      */
     private seedGroupMembership;
+    /** Append one entry to the shadow log for `chatId`. The shadow log is a
+     *  daily file at `.agentx/sessions/_telegram_raw:{chatId}:{day}.json` that
+     *  captures every allowed inbound (and adapter-side outbound) message
+     *  regardless of how the router resolved it — including periods when no
+     *  agent was bound or the daemon was offline (the next inbound triggers
+     *  a write). seedHistory reads it back on cold session create so a fresh
+     *  session mirrors the live chat instead of starting blank. */
+    private appendShadowLog;
+    private shadowLogPath;
+    /** ChannelAdapter.seedHistory: returns the most recent shadow-logged
+     *  messages for `chatId`, walking back day-by-day until we hit
+     *  `maxMessages` or `maxChars`. Telegram's Bot API has no "fetch chat
+     *  history" endpoint, so the shadow log is our only source — meaning the
+     *  first deployment sees an empty seed for any pre-existing chat, and
+     *  context grows as the bot observes new traffic. */
+    seedHistory(chatId: string, opts: {
+        sinceISO?: string;
+        maxMessages: number;
+        maxChars: number;
+    }): Promise<SeededMessage[]>;
     private apiCall;
 }
 
@@ -6705,6 +7858,16 @@ declare class WhatsAppAdapter implements ChannelAdapter {
         limit?: number;
         before?: string;
     }): Promise<HistoryMessage[]>;
+    /** ChannelAdapter.seedHistory: thin wrapper over getHistory() that maps
+     *  Baileys' HistoryMessage shape to the channel-agnostic SeededMessage
+     *  shape consumed by SessionStore on cold session create. Bounded by the
+     *  caller's maxMessages/maxChars; fromMe → role:agent. The chatId is the
+     *  Baileys jid (e.g., "21694xxx@s.whatsapp.net" for DMs). */
+    seedHistory(chatId: string, opts: {
+        sinceISO?: string;
+        maxMessages: number;
+        maxChars: number;
+    }): Promise<SeededMessage[]>;
     /** Token-bucket gate for live Baileys reads. Enforces
      *  `throttleMinMs` between calls and caps the per-minute call count.
      *  Returns a promise that resolves once it's safe to fire. */
@@ -6771,6 +7934,13 @@ declare class CronScheduler {
     stop(): Promise<void>;
     private scheduleNext;
     private scheduleRetry;
+    /**
+     * Phase 1 commit 6.d — record one cron-fire decision in the ledger
+     * when the source is enabled. Wrapped in try/catch so a ledger
+     * failure can never break cron dispatch — legacy stays authoritative
+     * until the 1c per-source promotion lands.
+     */
+    private recordCronDecisionInLedger;
     private executeJob;
     /**
      * Detect cron jobs that should have fired while the daemon was down.
@@ -6869,4 +8039,4 @@ declare function handleError(error: unknown): void;
  */
 declare function getPackageInfo(): PackageJson;
 
-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 };
+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$1 as 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$1 as 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 };