agentix-cli 0.17.0 → 0.18.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,33 @@ declare const agentConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
     mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** 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 +1374,7 @@ declare const agentConfigSchema: z.ZodObject<{
     workspace: string;
     tier: "claude-code" | "sdk" | "orchestrator";
     mentions: string[];
+    contextReferences: boolean;
     maxConcurrent: number;
     maxExecutionMinutes: number;
     permissionMode: string;
@@ -1346,6 +1389,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 +1403,13 @@ declare const agentConfigSchema: z.ZodObject<{
     tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
     systemPrompt?: string | undefined;
     mentions?: string[] | 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 +1531,33 @@ declare const daemonConfigSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         mentions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** 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 +1591,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
+        contextReferences: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
@@ -1522,6 +1606,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 +1620,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | 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;
@@ -2937,7 +3034,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 +3048,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;
@@ -3078,22 +3173,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,17 +3246,17 @@ 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;
     }>>;
@@ -3150,6 +3266,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         tier: "claude-code" | "sdk" | "orchestrator";
         mentions: string[];
+        contextReferences: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
@@ -3164,6 +3281,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;
@@ -3428,14 +3551,16 @@ 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;
     };
@@ -3496,6 +3621,13 @@ declare const daemonConfigSchema: z.ZodObject<{
         tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | 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;
@@ -3807,14 +3939,16 @@ 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;
@@ -3867,6 +4001,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.
      */
@@ -4024,6 +4180,10 @@ declare class AgentXDaemon {
      *  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). */
@@ -4359,6 +4519,262 @@ 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;
+}
+
+interface SessionMessage {
+    role: "user" | "agent";
+    name?: string;
+    content: string;
+    timestamp: 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;
+    constructor(baseDir?: string, opts?: {
+        staleMinutes?: number;
+        maxTurnsPerSession?: number;
+        tierTwoThresholdTokens?: number;
+    });
+    /**
+     * 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;
+    };
+    /**
+     * 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
@@ -5353,6 +5769,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 +5827,9 @@ 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;
     /**
      * Build peer list for context engine.
      */
@@ -5421,6 +5845,9 @@ declare class AgentRegistry {
     /**
      * 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;
@@ -6289,6 +6716,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;
@@ -6352,6 +6786,8 @@ 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.
@@ -6368,6 +6804,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 +6821,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
@@ -6869,4 +7309,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 };