agentix-cli 0.18.0 → 0.19.0

package/dist/index.d.ts

@@ -1314,6 +1314,25 @@ 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). */
@@ -1374,6 +1393,8 @@ declare const agentConfigSchema: z.ZodObject<{
     workspace: string;
     tier: "claude-code" | "sdk" | "orchestrator";
     mentions: string[];
+    intents: string[];
+    maxDelegationDepth: number;
     contextReferences: boolean;
     maxConcurrent: number;
     maxExecutionMinutes: number;
@@ -1403,6 +1424,8 @@ 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;
@@ -1531,6 +1554,25 @@ 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). */
@@ -1591,6 +1633,8 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
+        intents: string[];
+        maxDelegationDepth: number;
         contextReferences: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
@@ -1620,6 +1664,8 @@ 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;
@@ -2802,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;
@@ -2843,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;
     }, {
@@ -2863,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;
@@ -2884,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;
     }>>;
@@ -3107,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<{
@@ -3124,6 +3241,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseDir: string;
         autoApproveStructure: "any" | "strict" | "extend-leaves";
         autoApproveConfidence: number;
+        classifierModel: string;
         retrievalWeights: {
             graph: number;
             bm25: number;
@@ -3137,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;
@@ -3260,12 +3379,22 @@ declare const daemonConfigSchema: z.ZodObject<{
         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;
@@ -3312,6 +3441,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         baseDir: string;
         autoApproveStructure: "any" | "strict" | "extend-leaves";
         autoApproveConfidence: number;
+        classifierModel: string;
         retrievalWeights: {
             graph: number;
             bm25: number;
@@ -3564,8 +3694,14 @@ declare const daemonConfigSchema: z.ZodObject<{
         maxClaudeCodeDispatchesPerHour: number;
         maxClaudeCodeDispatchesPer5h: number;
     };
+    plugins: string[];
     business?: {
         enabled: boolean;
+        projects: {
+            id: string;
+            pm?: string | undefined;
+            client?: string | undefined;
+        }[];
         timezone: string;
         mainChannel: {
             channel: string;
@@ -3603,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;
@@ -3621,6 +3766,8 @@ 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;
@@ -3660,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;
@@ -3857,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;
@@ -3878,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;
@@ -3952,6 +4114,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         maxClaudeCodeDispatchesPerHour?: number | undefined;
         maxClaudeCodeDispatchesPer5h?: number | undefined;
     } | undefined;
+    plugins?: string[] | undefined;
 }>;
 type DaemonConfig = z.infer<typeof daemonConfigSchema>;
 type AgentDef = z.infer<typeof agentConfigSchema>;
@@ -3985,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.
@@ -4035,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
@@ -4075,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;
@@ -4093,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?;
@@ -4174,6 +4452,14 @@ 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
@@ -4429,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;
@@ -4588,11 +4887,156 @@ declare class MemoryStore {
     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;
@@ -4621,11 +5065,40 @@ declare class SessionStore {
     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.
      */
@@ -4704,6 +5177,34 @@ declare class SessionStore {
         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.
@@ -5559,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;
 
@@ -5579,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;
@@ -5655,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;
@@ -5747,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;
@@ -5830,6 +6420,18 @@ declare class AgentRegistry {
     /** 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.
      */
@@ -5840,8 +6442,21 @@ 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.
      */
@@ -5952,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;
@@ -6362,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;
@@ -6405,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;
 }, {
@@ -6425,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;
@@ -6446,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;
 }>;
@@ -6463,6 +7077,7 @@ interface EmployeeProfile {
 }
 declare class Organization {
     private employees;
+    private projects;
     constructor(config: BusinessConfig);
     get(agentId: string): EmployeeProfile | undefined;
     all(): EmployeeProfile[];
@@ -6470,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 {
@@ -6492,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). */
@@ -6769,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. */
@@ -6792,6 +7464,15 @@ declare class MessageRouter {
      * 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).
@@ -6889,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.
@@ -6896,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
@@ -6967,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;
 }
 
@@ -7145,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. */
@@ -7211,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.