agentix-cli 0.22.0 → 0.25.0

package/dist/index.d.ts

@@ -23,6 +23,12 @@ interface ProviderOptions {
     maxTokens?: number;
     temperature?: number;
     apiKey?: string;
+    /** Operator-cancel signal — passed straight to fetch() so the in-
+     *  flight HTTP request to the provider can be closed when the
+     *  task is cancelled. Without this, /api/tasks/:id/cancel only
+     *  marks the task aborted in the registry; the underlying request
+     *  can hang for hours waiting for the model to finish thinking. */
+    abortSignal?: AbortSignal;
 }
 type StreamEvent = {
     type: "text_delta";
@@ -37,6 +43,9 @@ type StreamEvent = {
 } | {
     type: "tool_use_end";
     name: string;
+} | {
+    type: "thinking_delta";
+    text: string;
 } | {
     type: "done";
     result: GenerationResult;
@@ -61,6 +70,9 @@ type ContentBlock = {
     tool_use_id: string;
     content: string;
     is_error?: boolean;
+} | {
+    type: "reasoning";
+    text: string;
 };
 interface RawGenerationResult {
     content: ContentBlock[];
@@ -80,9 +92,41 @@ interface AgentProvider {
         description: string;
         input_schema: Record<string, unknown>;
     }>, options?: ProviderOptions): Promise<RawGenerationResult>;
+    /**
+     * Streaming variant of generateRaw — emits text_delta events as the
+     * model generates so callers can pipe per-token to UIs (voice TTS,
+     * SSE, etc.) AND still get the full RawGenerationResult at the end
+     * with the tool_use blocks intact, so the agentic loop's tool
+     * dispatch keeps working unchanged. Optional — runAgenticLoop falls
+     * back to generateRaw() when this isn't implemented.
+     */
+    generateRawStream?(messages: AnthropicMessage[], systemPrompt: string, tools: Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>, options?: ProviderOptions): AsyncIterable<RawStreamEvent>;
 }
+/**
+ * Event stream from generateRawStream. text_delta arrives per chunk so
+ * the caller can stream to a UI; tool_use blocks accumulate silently and
+ * are surfaced in the terminal raw_result event so the agentic loop's
+ * tool dispatch logic stays unchanged.
+ */
+type RawStreamEvent = {
+    type: "text_delta";
+    text: string;
+} | {
+    type: "thinking_delta";
+    text: string;
+} | {
+    type: "raw_result";
+    result: RawGenerationResult;
+} | {
+    type: "error";
+    error: string;
+};
 declare const agentConfigSchema$1: z.ZodObject<{
-    provider: z.ZodDefault<z.ZodEnum<["claude-code", "claude", "openai", "ollama", "custom"]>>;
+    provider: z.ZodDefault<z.ZodEnum<["claude-code", "claude", "openai", "deepseek", "ollama", "demo", "custom"]>>;
     model: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
     skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -117,7 +161,7 @@ declare const agentConfigSchema$1: z.ZodObject<{
         disabledTools?: string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    provider: "claude-code" | "claude" | "openai" | "ollama" | "custom";
+    provider: "claude-code" | "claude" | "openai" | "deepseek" | "ollama" | "demo" | "custom";
     skills: string[];
     output: {
         dir: string;
@@ -134,7 +178,7 @@ declare const agentConfigSchema$1: z.ZodObject<{
     model?: string | undefined;
     apiKey?: string | undefined;
 }, {
-    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    provider?: "claude-code" | "claude" | "openai" | "deepseek" | "ollama" | "demo" | "custom" | undefined;
     model?: string | undefined;
     apiKey?: string | undefined;
     skills?: string[] | undefined;
@@ -168,6 +212,25 @@ declare class ClaudeProvider implements AgentProvider {
         input_schema: Record<string, unknown>;
     }>, options?: ProviderOptions): Promise<RawGenerationResult>;
     stream(messages: GenerationMessage[], options?: ProviderOptions): AsyncIterable<StreamEvent>;
+    /**
+     * Streaming variant of generateRaw — yields text_delta events per
+     * chunk so callers can pipe per-token to a UI, AND assembles the full
+     * RawGenerationResult (with tool_use blocks intact, stop_reason set)
+     * so the agentic loop's tool dispatch keeps working unchanged.
+     *
+     * Implementation mirrors stream() but:
+     *   - Targets generateRaw's signature (anthropicMessages + systemPrompt +
+     *     tools as parameters, not interleaved messages).
+     *   - Builds a ContentBlock[] with both text and tool_use blocks in the
+     *     order they arrived, so the agentic loop's `result.content.filter(
+     *     b => b.type === "tool_use")` still finds them.
+     *   - Yields one terminal `raw_result` event the loop consumes.
+     */
+    generateRawStream(messages: AnthropicMessage[], systemPrompt: string, tools: Array<{
+        name: string;
+        description: string;
+        input_schema: Record<string, unknown>;
+    }>, options?: ProviderOptions): AsyncIterable<RawStreamEvent>;
     private buildHeaders;
     private callApi;
     private parseResponse;
@@ -228,8 +291,14 @@ declare class ClaudeCodeProvider implements AgentProvider {
     private parseApiResponse;
 }
 
-type ProviderName = "claude-code" | "claude" | "openai" | "ollama" | "custom";
-declare function createProvider(name?: ProviderName, apiKey?: string): AgentProvider;
+type ProviderName = "claude-code" | "claude" | "openai" | "deepseek" | "ollama" | "demo" | "custom";
+interface CreateProviderOptions {
+    /** Toggle DeepSeek thinking-mode (`reasoning_content` blocks). Default
+     *  `true` for DeepSeek baseUrls. Wire this from
+     *  `providers.<name>.thinking` in agentx.json. */
+    thinking?: boolean;
+}
+declare function createProvider(name?: ProviderName, apiKey?: string, opts?: CreateProviderOptions): AgentProvider;
 
 interface MemoryEntry {
     id: string;
@@ -328,6 +397,41 @@ declare class HealEngine {
     private generateFix;
 }
 
+/**
+ * Get all tool definitions in Anthropic API format (for generateRaw()).
+ * Optionally filter by enabled tool names.
+ */
+declare function getAnthropicTools(enabledTools?: string[]): Array<{
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}>;
+/**
+ * Get the legacy tools (create_files + ask_user) for backward compatibility.
+ */
+declare function getLegacyTools(): Array<{
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}>;
+/**
+ * Format tool descriptions for inclusion in a system prompt.
+ * Used when the `claude` CLI binary handles its own tools —
+ * we describe our additional tools as text so the binary's built-in
+ * capabilities (read, write, bash) handle them natively.
+ */
+declare function formatToolsForSystemPrompt(): string;
+declare const ALL_TOOL_NAMES: string[];
+
+interface NoqtaToolContext {
+    /** The noqta.tn user UUID this tool call impersonates. */
+    userId: string;
+    /** Logical agent id (for the audit table's X-Agent-Id column). */
+    agentId?: string;
+    /** Override the noqta.tn base URL — defaults to NOQTA_API_URL env or https://noqta.tn. */
+    apiUrl?: string;
+}
+
 interface TechStack {
     languages: Language[];
     frameworks: Framework[];
@@ -467,6 +571,27 @@ interface SkillMatch {
     matchReason: string;
 }
 
+/** stdio MCP server — spawned as a child process, JSON-RPC over NDJSON
+ *  on stdin/stdout. The `type` field is optional for backward compat
+ *  with the original config shape (`{ command, args, env }`). */
+interface McpStdioSpec {
+    type?: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/** HTTP MCP server (Streamable HTTP transport) — POST JSON-RPC bodies to
+ *  `url`, server may answer as `application/json` or stream as
+ *  `text/event-stream` (`data: <json>` lines). Optional `headers` get
+ *  merged into every request (auth tokens, tenancy hints, etc.). */
+interface McpHttpSpec {
+    type: "http";
+    url: string;
+    headers?: Record<string, string>;
+}
+type McpServerSpec = McpStdioSpec | McpHttpSpec;
+type McpServerMap = Record<string, McpServerSpec>;
+
 interface AgentContext {
     techStack: TechStack;
     schemas: ProjectSchemas;
@@ -498,6 +623,34 @@ interface GenerateOptions {
         lintCommand?: string;
         maxAttempts?: number;
     };
+    /** Enables the noqta workspace tool catalog (list_projects, create_task,
+     *  …) in the agentic loop and threads the user_id through to the
+     *  executor. Without this set, the noqta-tools are absent from the
+     *  agent's tool list — keeps non-noqta agents clean. The bearer is
+     *  read from env at dispatch time and NEVER enters the prompt. */
+    noqtaContext?: NoqtaToolContext;
+    /** Provider-level options forwarded to `createProvider`. Today only
+     *  `thinking` (for DeepSeek thinking-mode). Wired from
+     *  `providers.<name>.thinking` in agentx.json by the daemon's
+     *  orchestrator-tier dispatch path. */
+    providerOpts?: {
+        thinking?: boolean;
+    };
+    /** Operator-cancel signal. When the daemon's task-cancel API fires
+     *  the AbortController, runAgenticLoop forwards this into the
+     *  provider's fetch() so the in-flight HTTP call is actually
+     *  closed. Without this, /api/tasks/:id/cancel for orchestrator-
+     *  tier agents only marks the task `cancelled` in the registry
+     *  while the underlying DeepSeek request keeps running (seen in
+     *  production: 100+ minute hangs). */
+    abortSignal?: AbortSignal;
+    /** External MCP servers to boot for this generation. Each entry is
+     *  spawned as a stdio child, its tools listed via tools/list, and
+     *  exposed to the agentic loop as `mcp__<server>__<tool>`. Wired
+     *  from `effectiveMcpConfig(agent)` by the orchestrator tier in
+     *  src/agents/runtime.ts — CLI-backed tiers (claude-code, codex-cli)
+     *  load their own `.mcp.json` natively and ignore this. */
+    mcpServers?: McpServerMap;
 }
 interface GenerateResult {
     files: WriteResult;
@@ -505,6 +658,11 @@ interface GenerateResult {
     outputType: OutputType;
     followUp?: string;
     tokensUsed?: number;
+    /** Split tokens when the provider supplies them (Claude raw mode does;
+     *  CLI mode and legacy fallbacks may not). Callers that bill by
+     *  direction should prefer these over a 30/70 estimate of tokensUsed. */
+    inputTokens?: number;
+    outputTokens?: number;
     healResult?: HealResult;
 }
 declare function createAgentContext(cwd: string, task: string, config?: Partial<AgentConfig>): Promise<AgentContext>;
@@ -562,32 +720,6 @@ interface OutputConfig {
 declare const OUTPUT_CONFIGS: Record<string, OutputConfig>;
 declare function resolveOutputType(userHint: string | undefined, taskDescription: string): OutputType;
 
-/**
- * Get all tool definitions in Anthropic API format (for generateRaw()).
- * Optionally filter by enabled tool names.
- */
-declare function getAnthropicTools(enabledTools?: string[]): Array<{
-    name: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-}>;
-/**
- * Get the legacy tools (create_files + ask_user) for backward compatibility.
- */
-declare function getLegacyTools(): Array<{
-    name: string;
-    description: string;
-    input_schema: Record<string, unknown>;
-}>;
-/**
- * Format tool descriptions for inclusion in a system prompt.
- * Used when the `claude` CLI binary handles its own tools —
- * we describe our additional tools as text so the binary's built-in
- * capabilities (read, write, bash) handle them natively.
- */
-declare function formatToolsForSystemPrompt(): string;
-declare const ALL_TOOL_NAMES: string[];
-
 interface ToolCallInput {
     name: string;
     id: string;
@@ -606,6 +738,16 @@ interface ToolExecutorOptions {
     interactive?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
+    /** When set, noqta-tools (list_projects, create_task, etc.) become
+     *  available — the executor dispatches them by POSTing to
+     *  /api/agent/tools with the server-held bearer. The bearer NEVER
+     *  enters the model's prompt context. Omit to leave noqta-tools off
+     *  (the agent will see "Unknown tool" if it calls one anyway). */
+    noqtaContext?: NoqtaToolContext;
+    /** Operator-cancel signal. When fired we short-circuit `execute()`
+     *  before dispatch and forward to execa as `cancelSignal` so a
+     *  hung shell command can't outlive the abort. */
+    abortSignal?: AbortSignal;
 }
 declare class ToolExecutor {
     private cwd;
@@ -928,7 +1070,7 @@ declare class PermissionManager {
 }
 declare const globalPermissions: PermissionManager;
 
-declare const HOOK_EVENTS: readonly ["pre:generate", "post:generate", "pre:file-write", "post:file-write", "pre:prompt", "post:response", "pre:command", "on:error", "pre:tool-call", "post:tool-call", "pre:channel-message", "post:channel-message", "pre:a2a-task", "pre:cron-run", "post:cron-run", "on:gitlab-pipeline", "on:gitlab-issue"];
+declare const HOOK_EVENTS: readonly ["pre:generate", "post:generate", "pre:file-write", "post:file-write", "pre:prompt", "post:response", "pre:command", "on:error", "pre:tool-call", "post:tool-call", "pre:channel-message", "post:channel-message", "pre:a2a-task", "pre:cron-run", "post:cron-run", "on:gitlab-pipeline", "on:gitlab-issue", "on:gitlab-mr", "on:gitlab-note", "on:github-issue", "on:github-pr", "on:github-push", "on:stripe-event", "on:sentry-issue", "on:vercel-deployment", "on:odoo-event", "on:hubspot-event"];
 type HookEvent = (typeof HOOK_EVENTS)[number];
 declare const BLOCKING_EVENTS: HookEvent[];
 declare const hookDefinitionSchema: z.ZodObject<{
@@ -936,7 +1078,7 @@ declare const hookDefinitionSchema: z.ZodObject<{
     type: z.ZodEnum<["command", "prompt", "script"]>;
     command: z.ZodOptional<z.ZodString>;
     prompt: z.ZodOptional<z.ZodString>;
-    provider: z.ZodOptional<z.ZodEnum<["claude-code", "claude", "openai", "ollama", "custom"]>>;
+    provider: z.ZodOptional<z.ZodEnum<["claude-code", "claude", "openai", "deepseek", "ollama", "custom"]>>;
     model: z.ZodOptional<z.ZodString>;
     script: z.ZodOptional<z.ZodString>;
     priority: z.ZodDefault<z.ZodNumber>;
@@ -946,7 +1088,7 @@ declare const hookDefinitionSchema: z.ZodObject<{
     enabled: boolean;
     name: string;
     priority: number;
-    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    provider?: "claude-code" | "claude" | "openai" | "deepseek" | "ollama" | "custom" | undefined;
     model?: string | undefined;
     script?: string | undefined;
     command?: string | undefined;
@@ -954,7 +1096,7 @@ declare const hookDefinitionSchema: z.ZodObject<{
 }, {
     type: "script" | "command" | "prompt";
     name: string;
-    provider?: "claude-code" | "claude" | "openai" | "ollama" | "custom" | undefined;
+    provider?: "claude-code" | "claude" | "openai" | "deepseek" | "ollama" | "custom" | undefined;
     model?: string | undefined;
     enabled?: boolean | undefined;
     script?: string | undefined;
@@ -1309,7 +1451,7 @@ declare class A2AClient {
 declare const agentConfigSchema: z.ZodObject<{
     name: z.ZodString;
     workspace: z.ZodString;
-    tier: z.ZodDefault<z.ZodEnum<["claude-code", "sdk", "orchestrator"]>>;
+    tier: z.ZodDefault<z.ZodEnum<["claude-code", "codex-cli", "opencode", "sdk", "orchestrator"]>>;
     provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
@@ -1336,19 +1478,44 @@ declare const agentConfigSchema: z.ZodObject<{
     /** 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<{
+    mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"http">;
+        url: z.ZodString;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "http";
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }, {
+        type: "http";
+        url: string;
+        headers?: Record<string, string> | undefined;
+    }>, z.ZodObject<{
+        type: z.ZodOptional<z.ZodLiteral<"stdio">>;
         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[];
+        type?: "stdio" | undefined;
         env?: Record<string, string> | undefined;
     }, {
         command: string;
+        type?: "stdio" | undefined;
         env?: Record<string, string> | undefined;
         args?: string[] | undefined;
-    }>>>;
+    }>]>>>;
+    /** Enable CodeGraph (https://github.com/colbymchenry/codegraph) for this
+     *  agent's claude-code or codex-cli workspace. When true, agentx (a) adds
+     *  a codegraph MCP server to <workspace>/.mcp.json, (b) extends
+     *  .claude/settings.json permissions.allow with the codegraph_* tools,
+     *  (c) appends a CodeGraph instruction section to the managed CLAUDE.md,
+     *  and (d) background-indexes the workspace at daemon boot if .codegraph/
+     *  is missing. Off by default — flip on for coding agents (mtgl-v2-coder,
+     *  ksi-v2-coder, hasanah-coding, etc.) where token-volume on exploration
+     *  loops is the bottleneck. */
+    codegraph: z.ZodDefault<z.ZodBoolean>;
     /** 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
@@ -1360,12 +1527,39 @@ declare const agentConfigSchema: z.ZodObject<{
      *  etc.) once a `references/` registry exists in the agent's workspace
      *  or repo root. See src/agents/references/. */
     contextReferences: z.ZodDefault<z.ZodBoolean>;
+    /** Whether this agent may emit in-band `agentx:ui` rich-message directives
+     *  (buttons/polls/media) on chat channels. Default true — set false to make
+     *  the render layer strip any directive and send plain text only. */
+    richMessages: 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
      *  agents that do long investigations or multi-file refactors. */
     maxExecutionMinutes: z.ZodDefault<z.ZodNumber>;
     permissionMode: z.ZodDefault<z.ZodString>;
+    /** Improvement plan #3 — tool-use-required preset. When set,
+     *  AgentX inspects the stream-json events from each task and
+     *  fails the response with `tool_required_not_called: <name>`
+     *  when none of the listed tool names was invoked. Catches the
+     *  silent-degrade pattern observed when a model below the
+     *  capability bar (e.g. Haiku on a Write-required prompt)
+     *  produces a plausible-looking text response without ever
+     *  calling the required tool. Caller can retry with a stronger
+     *  model or sharpen the prompt.
+     *
+     *  Tool names match the canonical Claude Code names ("Write",
+     *  "Edit", "Bash", "Read", …). Free-form so future tools work
+     *  without a schema bump. Empty/unset means no enforcement
+     *  (default — backward compatible). */
+    toolUseRequired: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Per-agent override for the channel-level `autoReplyLegacy` on
+     *  gitlab/github. When set, it wins over `channels.<name>.autoReplyLegacy`
+     *  for this agent's replies: `true` makes the daemon auto-post the agent's
+     *  final text as a comment (right for coder agents that end their turn with
+     *  a summary and don't call `agentx_channel_reply`); `false` suppresses it
+     *  (right for chatty agents whose reasoning shouldn't land as a comment).
+     *  Unset → fall back to the channel default. */
+    gitlabAutoReply: z.ZodOptional<z.ZodBoolean>;
     /** When true, this agent's claude-code dispatches reuse a long-lived
      *  subprocess per (channel, chatId) instead of spawning a fresh
      *  `claude -p` per turn. Driven over stdin via stream-json input,
@@ -1401,17 +1595,102 @@ declare const agentConfigSchema: z.ZodObject<{
      *   - "public": external apps can POST /api/public/agents/<id>/messages
      *     with a scoped token (agent:<id> or agent:*). */
     access: z.ZodDefault<z.ZodEnum<["private", "public"]>>;
+    /** Per-agent third-party integrations registry. Declares which services
+     *  this agent has credentials for (telegram-bot, hubspot, gitlab-user,
+     *  gmail, etc.). Secrets stay in env vars / keyring; this block holds
+     *  declarations + non-secret metadata only. Skills and channel adapters
+     *  read from here to know what the agent can use. See INTEGRATION_KINDS. */
+    integrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Service identifier — open string, well-known values in INTEGRATION_KINDS. */
+        kind: z.ZodString;
+        /** Human-readable label (e.g. "@cx_bot", "Noqta CRM", "anis@noqta.tn"). Unique per (agent, kind). */
+        label: z.ZodString;
+        credentials: z.ZodDefault<z.ZodObject<{
+            /** Env var holding the secret. Uppercase identifier; daemon resolves at use-time. */
+            tokenEnv: z.ZodOptional<z.ZodString>;
+            /** Alternate env-var keys for credential schemes that need >1 secret
+             *  (e.g. HubSpot private app + portal id, OAuth refresh tokens). */
+            privateAppTokenEnv: z.ZodOptional<z.ZodString>;
+            apiKeyEnv: z.ZodOptional<z.ZodString>;
+            refreshTokenEnv: z.ZodOptional<z.ZodString>;
+            clientIdEnv: z.ZodOptional<z.ZodString>;
+            clientSecretEnv: z.ZodOptional<z.ZodString>;
+            /** OS keyring directive — credential lives in macOS Keychain / Linux
+             *  Secret Service / Windows Credential Manager. The skill that reads
+             *  this integration is responsible for resolving the keyring entry
+             *  (typically keyed by agentId+kind). */
+            auth: z.ZodOptional<z.ZodLiteral<"keyring">>;
+            /** File-based session directory (WhatsApp, Telegram MTProto, etc.). */
+            sessionDir: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        }, {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        }>>;
+        /** Non-secret metadata — username, email, host URL, portal id, JID, etc.
+         *  Visible in the dashboard and to skills. */
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        /** Operator-set toggle without removing the entry. */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        credentials: {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        };
+        metadata: Record<string, string | number | boolean>;
+        label: string;
+        kind: string;
+    }, {
+        label: string;
+        kind: string;
+        enabled?: boolean | undefined;
+        credentials?: {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     workspace: string;
-    tier: "claude-code" | "sdk" | "orchestrator";
+    tier: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator";
     mentions: string[];
     intents: string[];
     maxDelegationDepth: number;
+    codegraph: boolean;
     contextReferences: boolean;
+    richMessages: boolean;
     maxConcurrent: number;
     maxExecutionMinutes: number;
     permissionMode: string;
+    toolUseRequired: string[];
     persistentProcess: boolean;
     queueMode: "collect" | "followup" | "drop";
     heartbeat: {
@@ -1421,35 +1700,66 @@ declare const agentConfigSchema: z.ZodObject<{
         intervalMinutes: number;
     };
     access: "private" | "public";
+    integrations: {
+        enabled: boolean;
+        credentials: {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        };
+        metadata: Record<string, string | number | boolean>;
+        label: string;
+        kind: string;
+    }[];
     provider?: string | undefined;
     model?: string | undefined;
     systemPrompt?: string | undefined;
     mcp?: Record<string, {
         command: string;
         args: string[];
+        type?: "stdio" | undefined;
         env?: Record<string, string> | undefined;
+    } | {
+        type: "http";
+        url: string;
+        headers?: Record<string, string> | undefined;
     }> | undefined;
     contextStrategy?: "layered" | "planner" | undefined;
+    gitlabAutoReply?: boolean | undefined;
 }, {
     name: string;
     workspace: string;
     provider?: string | undefined;
     model?: string | undefined;
-    tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+    tier?: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator" | undefined;
     systemPrompt?: string | undefined;
     mentions?: string[] | undefined;
     intents?: string[] | undefined;
     maxDelegationDepth?: number | undefined;
     mcp?: Record<string, {
         command: string;
+        type?: "stdio" | undefined;
         env?: Record<string, string> | undefined;
         args?: string[] | undefined;
+    } | {
+        type: "http";
+        url: string;
+        headers?: Record<string, string> | undefined;
     }> | undefined;
+    codegraph?: boolean | undefined;
     contextStrategy?: "layered" | "planner" | undefined;
     contextReferences?: boolean | undefined;
+    richMessages?: boolean | undefined;
     maxConcurrent?: number | undefined;
     maxExecutionMinutes?: number | undefined;
     permissionMode?: string | undefined;
+    toolUseRequired?: string[] | undefined;
+    gitlabAutoReply?: boolean | undefined;
     persistentProcess?: boolean | undefined;
     queueMode?: "collect" | "followup" | "drop" | undefined;
     heartbeat?: {
@@ -1459,6 +1769,22 @@ declare const agentConfigSchema: z.ZodObject<{
         intervalMinutes?: number | undefined;
     } | undefined;
     access?: "private" | "public" | undefined;
+    integrations?: {
+        label: string;
+        kind: string;
+        enabled?: boolean | undefined;
+        credentials?: {
+            tokenEnv?: string | undefined;
+            privateAppTokenEnv?: string | undefined;
+            apiKeyEnv?: string | undefined;
+            refreshTokenEnv?: string | undefined;
+            clientIdEnv?: string | undefined;
+            clientSecretEnv?: string | undefined;
+            auth?: "keyring" | undefined;
+            sessionDir?: string | undefined;
+        } | undefined;
+        metadata?: Record<string, string | number | boolean> | undefined;
+    }[] | undefined;
 }>;
 declare const cronJobSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -1552,19 +1878,28 @@ declare const daemonConfigSchema: z.ZodObject<{
         apiKey: z.ZodOptional<z.ZodString>;
         defaultModel: z.ZodOptional<z.ZodString>;
         baseUrl: z.ZodOptional<z.ZodString>;
+        /** Toggle thinking-mode output on backends that support it (DeepSeek
+         *  V4 `reasoning_content`). When `true` (the DeepSeek default), the
+         *  agent streams its reasoning live in the dashboard task modal and
+         *  the agentic round-trip echoes it back on the next iteration. Set
+         *  to `false` to disable for cost/latency-sensitive agents. Ignored
+         *  on backends that don't speak the thinking-mode protocol. */
+        thinking: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         apiKey?: string | undefined;
+        thinking?: boolean | undefined;
         defaultModel?: string | undefined;
         baseUrl?: string | undefined;
     }, {
         apiKey?: string | undefined;
+        thinking?: boolean | undefined;
         defaultModel?: string | undefined;
         baseUrl?: string | undefined;
     }>>>;
     agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
         workspace: z.ZodString;
-        tier: z.ZodDefault<z.ZodEnum<["claude-code", "sdk", "orchestrator"]>>;
+        tier: z.ZodDefault<z.ZodEnum<["claude-code", "codex-cli", "opencode", "sdk", "orchestrator"]>>;
         provider: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         systemPrompt: z.ZodOptional<z.ZodString>;
@@ -1591,19 +1926,44 @@ declare const daemonConfigSchema: z.ZodObject<{
         /** 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<{
+        mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"http">;
+            url: z.ZodString;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }, {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodOptional<z.ZodLiteral<"stdio">>;
             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[];
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
         }, {
             command: string;
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
             args?: string[] | undefined;
-        }>>>;
+        }>]>>>;
+        /** Enable CodeGraph (https://github.com/colbymchenry/codegraph) for this
+         *  agent's claude-code or codex-cli workspace. When true, agentx (a) adds
+         *  a codegraph MCP server to <workspace>/.mcp.json, (b) extends
+         *  .claude/settings.json permissions.allow with the codegraph_* tools,
+         *  (c) appends a CodeGraph instruction section to the managed CLAUDE.md,
+         *  and (d) background-indexes the workspace at daemon boot if .codegraph/
+         *  is missing. Off by default — flip on for coding agents (mtgl-v2-coder,
+         *  ksi-v2-coder, hasanah-coding, etc.) where token-volume on exploration
+         *  loops is the bottleneck. */
+        codegraph: z.ZodDefault<z.ZodBoolean>;
         /** 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
@@ -1615,12 +1975,39 @@ declare const daemonConfigSchema: z.ZodObject<{
          *  etc.) once a `references/` registry exists in the agent's workspace
          *  or repo root. See src/agents/references/. */
         contextReferences: z.ZodDefault<z.ZodBoolean>;
+        /** Whether this agent may emit in-band `agentx:ui` rich-message directives
+         *  (buttons/polls/media) on chat channels. Default true — set false to make
+         *  the render layer strip any directive and send plain text only. */
+        richMessages: 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
          *  agents that do long investigations or multi-file refactors. */
         maxExecutionMinutes: z.ZodDefault<z.ZodNumber>;
         permissionMode: z.ZodDefault<z.ZodString>;
+        /** Improvement plan #3 — tool-use-required preset. When set,
+         *  AgentX inspects the stream-json events from each task and
+         *  fails the response with `tool_required_not_called: <name>`
+         *  when none of the listed tool names was invoked. Catches the
+         *  silent-degrade pattern observed when a model below the
+         *  capability bar (e.g. Haiku on a Write-required prompt)
+         *  produces a plausible-looking text response without ever
+         *  calling the required tool. Caller can retry with a stronger
+         *  model or sharpen the prompt.
+         *
+         *  Tool names match the canonical Claude Code names ("Write",
+         *  "Edit", "Bash", "Read", …). Free-form so future tools work
+         *  without a schema bump. Empty/unset means no enforcement
+         *  (default — backward compatible). */
+        toolUseRequired: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Per-agent override for the channel-level `autoReplyLegacy` on
+         *  gitlab/github. When set, it wins over `channels.<name>.autoReplyLegacy`
+         *  for this agent's replies: `true` makes the daemon auto-post the agent's
+         *  final text as a comment (right for coder agents that end their turn with
+         *  a summary and don't call `agentx_channel_reply`); `false` suppresses it
+         *  (right for chatty agents whose reasoning shouldn't land as a comment).
+         *  Unset → fall back to the channel default. */
+        gitlabAutoReply: z.ZodOptional<z.ZodBoolean>;
         /** When true, this agent's claude-code dispatches reuse a long-lived
          *  subprocess per (channel, chatId) instead of spawning a fresh
          *  `claude -p` per turn. Driven over stdin via stream-json input,
@@ -1656,17 +2043,102 @@ declare const daemonConfigSchema: z.ZodObject<{
          *   - "public": external apps can POST /api/public/agents/<id>/messages
          *     with a scoped token (agent:<id> or agent:*). */
         access: z.ZodDefault<z.ZodEnum<["private", "public"]>>;
+        /** Per-agent third-party integrations registry. Declares which services
+         *  this agent has credentials for (telegram-bot, hubspot, gitlab-user,
+         *  gmail, etc.). Secrets stay in env vars / keyring; this block holds
+         *  declarations + non-secret metadata only. Skills and channel adapters
+         *  read from here to know what the agent can use. See INTEGRATION_KINDS. */
+        integrations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Service identifier — open string, well-known values in INTEGRATION_KINDS. */
+            kind: z.ZodString;
+            /** Human-readable label (e.g. "@cx_bot", "Noqta CRM", "anis@noqta.tn"). Unique per (agent, kind). */
+            label: z.ZodString;
+            credentials: z.ZodDefault<z.ZodObject<{
+                /** Env var holding the secret. Uppercase identifier; daemon resolves at use-time. */
+                tokenEnv: z.ZodOptional<z.ZodString>;
+                /** Alternate env-var keys for credential schemes that need >1 secret
+                 *  (e.g. HubSpot private app + portal id, OAuth refresh tokens). */
+                privateAppTokenEnv: z.ZodOptional<z.ZodString>;
+                apiKeyEnv: z.ZodOptional<z.ZodString>;
+                refreshTokenEnv: z.ZodOptional<z.ZodString>;
+                clientIdEnv: z.ZodOptional<z.ZodString>;
+                clientSecretEnv: z.ZodOptional<z.ZodString>;
+                /** OS keyring directive — credential lives in macOS Keychain / Linux
+                 *  Secret Service / Windows Credential Manager. The skill that reads
+                 *  this integration is responsible for resolving the keyring entry
+                 *  (typically keyed by agentId+kind). */
+                auth: z.ZodOptional<z.ZodLiteral<"keyring">>;
+                /** File-based session directory (WhatsApp, Telegram MTProto, etc.). */
+                sessionDir: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            }, {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            }>>;
+            /** Non-secret metadata — username, email, host URL, portal id, JID, etc.
+             *  Visible in the dashboard and to skills. */
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            /** Operator-set toggle without removing the entry. */
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            credentials: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            };
+            metadata: Record<string, string | number | boolean>;
+            label: string;
+            kind: string;
+        }, {
+            label: string;
+            kind: string;
+            enabled?: boolean | undefined;
+            credentials?: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            } | undefined;
+            metadata?: Record<string, string | number | boolean> | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         workspace: string;
-        tier: "claude-code" | "sdk" | "orchestrator";
+        tier: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator";
         mentions: string[];
         intents: string[];
         maxDelegationDepth: number;
+        codegraph: boolean;
         contextReferences: boolean;
+        richMessages: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
+        toolUseRequired: string[];
         persistentProcess: boolean;
         queueMode: "collect" | "followup" | "drop";
         heartbeat: {
@@ -1676,35 +2148,66 @@ declare const daemonConfigSchema: z.ZodObject<{
             intervalMinutes: number;
         };
         access: "private" | "public";
+        integrations: {
+            enabled: boolean;
+            credentials: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            };
+            metadata: Record<string, string | number | boolean>;
+            label: string;
+            kind: string;
+        }[];
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
         mcp?: Record<string, {
             command: string;
             args: string[];
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
+        } | {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
         }> | undefined;
         contextStrategy?: "layered" | "planner" | undefined;
+        gitlabAutoReply?: boolean | undefined;
     }, {
         name: string;
         workspace: string;
         provider?: string | undefined;
         model?: string | undefined;
-        tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        tier?: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         intents?: string[] | undefined;
         maxDelegationDepth?: number | undefined;
         mcp?: Record<string, {
             command: string;
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
             args?: string[] | undefined;
+        } | {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
         }> | undefined;
+        codegraph?: boolean | undefined;
         contextStrategy?: "layered" | "planner" | undefined;
         contextReferences?: boolean | undefined;
+        richMessages?: boolean | undefined;
         maxConcurrent?: number | undefined;
         maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
+        toolUseRequired?: string[] | undefined;
+        gitlabAutoReply?: boolean | undefined;
         persistentProcess?: boolean | undefined;
         queueMode?: "collect" | "followup" | "drop" | undefined;
         heartbeat?: {
@@ -1714,6 +2217,22 @@ declare const daemonConfigSchema: z.ZodObject<{
             intervalMinutes?: number | undefined;
         } | undefined;
         access?: "private" | "public" | undefined;
+        integrations?: {
+            label: string;
+            kind: string;
+            enabled?: boolean | undefined;
+            credentials?: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            } | undefined;
+            metadata?: Record<string, string | number | boolean> | undefined;
+        }[] | undefined;
     }>>>;
     channels: z.ZodDefault<z.ZodObject<{
         telegram: z.ZodDefault<z.ZodObject<{
@@ -1909,8 +2428,8 @@ declare const daemonConfigSchema: z.ZodObject<{
             defaultAgent?: string | undefined;
         }, {
             enabled?: boolean | undefined;
-            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
+            allowFrom?: string[] | undefined;
             defaultAgent?: string | undefined;
             routes?: {
                 agent: string;
@@ -1935,43 +2454,19 @@ declare const daemonConfigSchema: z.ZodObject<{
                 retentionDays?: number | undefined;
             } | undefined;
         }>>;
-        discord: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            token: z.ZodOptional<z.ZodString>;
-            agentBinding: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            enabled: boolean;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        }, {
-            enabled?: boolean | undefined;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        }>>;
-        slack: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            /** xoxb-... — bot user OAuth token from the Slack app's "OAuth & Permissions" tab. */
-            botToken: z.ZodOptional<z.ZodString>;
-            /** xapp-... — app-level token with connections:write scope (for Socket Mode). */
-            appToken: z.ZodOptional<z.ZodString>;
-            agentBinding: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            enabled: boolean;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
-        }, {
-            enabled?: boolean | undefined;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
-        }>>;
         gitlab: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             webhookPort: z.ZodDefault<z.ZodNumber>;
             webhookSecret: z.ZodOptional<z.ZodString>;
             host: z.ZodDefault<z.ZodString>;
             token: z.ZodOptional<z.ZodString>;
+            /** Legacy auto-reply: when true (default), the router posts the agent's
+             *  `response.content` as a comment automatically. When false, the agent
+             *  must call the `channel.reply` action explicitly to reply — agent
+             *  reasoning text is logged but not posted. Flip to false once the
+             *  project's agents have migrated their gitlab skill to use channel.reply.
+             *  Default true preserves today's behaviour for unmigrated projects. */
+            autoReplyLegacy: z.ZodDefault<z.ZodBoolean>;
             routes: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 project: z.ZodString;
                 agent: z.ZodString;
@@ -2013,6 +2508,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             }[];
             webhookPort: number;
             host: string;
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
@@ -2032,6 +2528,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
             host?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -2042,6 +2539,9 @@ declare const daemonConfigSchema: z.ZodObject<{
         }>>;
         github: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Legacy auto-reply — same semantics as gitlab.autoReplyLegacy.
+             *  Defaults true; set false once agent skills use channel.reply. */
+            autoReplyLegacy: z.ZodDefault<z.ZodBoolean>;
             /** GitHub PAT or env var (${GITHUB_TOKEN}) for posting comments back. */
             token: z.ZodOptional<z.ZodString>;
             /** Path to file containing the token (first line read at startup). */
@@ -2091,6 +2591,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 agent: string;
                 repo: string;
             }[];
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 githubUsernames: string[];
@@ -2112,6 +2613,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 repo: string;
             }[] | undefined;
             webhookSecret?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -2290,6 +2792,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             }[];
             webhookPort: number;
             host: string;
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
@@ -2300,20 +2803,6 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             webhookSecret?: string | undefined;
         };
-        telegram: {
-            enabled: boolean;
-            accounts: Record<string, {
-                token: string;
-                agentBinding: string;
-                pollInbound: boolean;
-                allowFrom?: string[] | undefined;
-            }>;
-            policy: {
-                dm: "block" | "pair";
-                group: "all" | "mention-required";
-                allowFrom?: string[] | undefined;
-            };
-        };
         whatsapp: {
             enabled: boolean;
             sessionDir: string;
@@ -2342,16 +2831,19 @@ declare const daemonConfigSchema: z.ZodObject<{
             allowFrom?: string[] | undefined;
             defaultAgent?: string | undefined;
         };
-        discord: {
-            enabled: boolean;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        };
-        slack: {
+        telegram: {
             enabled: boolean;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
+            accounts: Record<string, {
+                token: string;
+                agentBinding: string;
+                pollInbound: boolean;
+                allowFrom?: string[] | undefined;
+            }>;
+            policy: {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
+            };
         };
         github: {
             enabled: boolean;
@@ -2359,6 +2851,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 agent: string;
                 repo: string;
             }[];
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 githubUsernames: string[];
@@ -2414,6 +2907,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
             host?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -2422,24 +2916,10 @@ declare const daemonConfigSchema: z.ZodObject<{
                 node?: string | undefined;
             }[] | undefined;
         } | undefined;
-        telegram?: {
-            enabled?: boolean | undefined;
-            accounts?: Record<string, {
-                token: string;
-                agentBinding: string;
-                allowFrom?: string[] | undefined;
-                pollInbound?: boolean | undefined;
-            }> | undefined;
-            policy?: {
-                allowFrom?: string[] | undefined;
-                dm?: "block" | "pair" | undefined;
-                group?: "all" | "mention-required" | undefined;
-            } | undefined;
-        } | undefined;
         whatsapp?: {
             enabled?: boolean | undefined;
-            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
+            allowFrom?: string[] | undefined;
             defaultAgent?: string | undefined;
             routes?: {
                 agent: string;
@@ -2464,16 +2944,19 @@ declare const daemonConfigSchema: z.ZodObject<{
                 retentionDays?: number | undefined;
             } | undefined;
         } | undefined;
-        discord?: {
-            enabled?: boolean | undefined;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        } | undefined;
-        slack?: {
+        telegram?: {
             enabled?: boolean | undefined;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
+            accounts?: Record<string, {
+                token: string;
+                agentBinding: string;
+                allowFrom?: string[] | undefined;
+                pollInbound?: boolean | undefined;
+            }> | undefined;
+            policy?: {
+                allowFrom?: string[] | undefined;
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            } | undefined;
         } | undefined;
         github?: {
             enabled?: boolean | undefined;
@@ -2483,6 +2966,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 repo: string;
             }[] | undefined;
             webhookSecret?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -3095,7 +3579,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         }, "strip", z.ZodTypeAny, {
             id: string;
             title: string;
-            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            kind: "label" | "open-backlog" | "scoped-label" | "closed";
             scopedPrefix: string;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
@@ -3103,7 +3587,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         }, {
             id: string;
             title: string;
-            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            kind?: "label" | "open-backlog" | "scoped-label" | "closed" | undefined;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
             scopedPrefix?: string | undefined;
@@ -3145,7 +3629,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         columns: {
             id: string;
             title: string;
-            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            kind: "label" | "open-backlog" | "scoped-label" | "closed";
             scopedPrefix: string;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
@@ -3177,7 +3661,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         columns?: {
             id: string;
             title: string;
-            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            kind?: "label" | "open-backlog" | "scoped-label" | "closed" | undefined;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
             scopedPrefix?: string | undefined;
@@ -3325,6 +3809,22 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         dir: z.ZodDefault<z.ZodString>;
+        matching: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            mode: z.ZodDefault<z.ZodEnum<["suggest", "auto"]>>;
+            autoRunThreshold: z.ZodDefault<z.ZodNumber>;
+            suggestThreshold: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            mode: "auto" | "suggest";
+            autoRunThreshold: number;
+            suggestThreshold: number;
+        }, {
+            enabled?: boolean | undefined;
+            mode?: "auto" | "suggest" | undefined;
+            autoRunThreshold?: number | undefined;
+            suggestThreshold?: number | undefined;
+        }>>;
         /** Controls whether the dashboard exposes the visual editor. "readonly"
          *  serves the list + run timelines but strips write controls from the
          *  page. "disabled" hides the tab entirely. */
@@ -3332,18 +3832,108 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         dir: string;
         enabled: boolean;
+        matching: {
+            enabled: boolean;
+            mode: "auto" | "suggest";
+            autoRunThreshold: number;
+            suggestThreshold: number;
+        };
         editor: "disabled" | "readonly" | "edit";
     }, {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        matching?: {
+            enabled?: boolean | undefined;
+            mode?: "auto" | "suggest" | undefined;
+            autoRunThreshold?: number | undefined;
+            suggestThreshold?: number | undefined;
+        } | undefined;
         editor?: "disabled" | "readonly" | "edit" | undefined;
     }>>;
+    /** Procedures — user-perspective SOPs mined from recurring activity.
+     *  The extraction cadence itself lives in `crons.procedure-extract`
+     *  (written by `agentx procedure watch`); this block holds the miner's
+     *  thresholds and the injection gates the daemon reads. */
+    procedures: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        dir: z.ZodDefault<z.ZodString>;
+        extraction: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Count patterns live after each completed task (no LLM cost). */
+            onTaskCompletion: z.ZodDefault<z.ZodBoolean>;
+            minOccurrences: z.ZodDefault<z.ZodNumber>;
+            sinceDays: z.ZodDefault<z.ZodNumber>;
+            maxClusters: z.ZodDefault<z.ZodNumber>;
+            /** Agent whose session distills drafts (LLM path). */
+            via: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            onTaskCompletion: boolean;
+            minOccurrences: number;
+            sinceDays: number;
+            maxClusters: number;
+            via?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            onTaskCompletion?: boolean | undefined;
+            minOccurrences?: number | undefined;
+            sinceDays?: number | undefined;
+            maxClusters?: number | undefined;
+            via?: string | undefined;
+        }>>;
+        /** Inject matching procedures into fresh agent sessions as guidance. */
+        injection: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            maxProcedures: z.ZodDefault<z.ZodNumber>;
+            minScore: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            maxProcedures: number;
+            minScore: number;
+        }, {
+            enabled?: boolean | undefined;
+            maxProcedures?: number | undefined;
+            minScore?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        dir: string;
+        enabled: boolean;
+        extraction: {
+            enabled: boolean;
+            onTaskCompletion: boolean;
+            minOccurrences: number;
+            sinceDays: number;
+            maxClusters: number;
+            via?: string | undefined;
+        };
+        injection: {
+            enabled: boolean;
+            maxProcedures: number;
+            minScore: number;
+        };
+    }, {
+        dir?: string | undefined;
+        enabled?: boolean | undefined;
+        extraction?: {
+            enabled?: boolean | undefined;
+            onTaskCompletion?: boolean | undefined;
+            minOccurrences?: number | undefined;
+            sinceDays?: number | undefined;
+            maxClusters?: number | undefined;
+            via?: string | undefined;
+        } | undefined;
+        injection?: {
+            enabled?: boolean | undefined;
+            maxProcedures?: number | undefined;
+            minScore?: number | undefined;
+        } | undefined;
+    }>>;
     /** Registered inbound webhooks — an inventory the dashboard manages. Each
      *  entry binds an (agent, source) pair to an optional signing secret. The
      *  actual inbound URL is always POST /webhook/<agentId>/<source>. */
     webhooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        source: z.ZodEnum<["gitlab", "github", "sentry", "stripe", "discord", "slack", "custom"]>;
+        source: z.ZodString;
         agentId: z.ZodString;
         secretEnv: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
@@ -3370,7 +3960,7 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         id: string;
-        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        source: string;
         agentId: string;
         description?: string | undefined;
         triggers?: Record<string, string> | undefined;
@@ -3379,7 +3969,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         defaultWorkflow?: string | undefined;
     }, {
         id: string;
-        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        source: string;
         agentId: string;
         enabled?: boolean | undefined;
         description?: string | undefined;
@@ -3389,17 +3979,19 @@ declare const daemonConfigSchema: z.ZodObject<{
         defaultWorkflow?: string | undefined;
     }>, "many">>;
     /** Session cache-reuse policy. Controls when we drop a Claude `--resume`
-     *  session and rebuild the prompt from scratch.
-     *  - `staleMinutes`: idle timeout before rotation. Longer is cheaper at
-     *    Opus rates but lets a session accumulate tool-result bloat across an
-     *    all-day chat.
-     *  - `maxTurnsPerSession`: hard cap on turns per Claude session. Prevents
-     *    unbounded `--resume` growth. When hit, next turn starts fresh with
-     *    the compacted summary + recent-messages context.
-     *  - `tierTwoThresholdTokens`: if the prior turn's (input + cacheRead +
-     *    cacheCreate) exceeded this, rotate proactively. Claude bills tier-2
-     *    at 1.5× above 200K total input, so rotating before that threshold
-     *    undercuts the multiplier. */
+     *  session and rebuild the prompt from scratch. Every rotation captures a
+     *  continuity memo that's injected into the chat's next fresh session.
+     *  - `staleMinutes`: idle timeout before rotation. 12 h default — chat
+     *    conversations must survive a workday's pauses; overnight silence
+     *    starts fresh.
+     *  - `maxTurnsPerSession`: backstop cap on turns per Claude session.
+     *    Size-based rotation measures real context now, so this rarely fires
+     *    first.
+     *  - `tierTwoThresholdTokens`: rotate when the prior turn's END-OF-TURN
+     *    per-request context (last API call's input + cacheRead + cacheCreate)
+     *    reaches this. Claude bills the 1.5× long-context rate above 200K
+     *    per REQUEST — 180K leaves headroom. NOT the cumulative turn total:
+     *    that sums cache reads across every call and reads 10-20× too high. */
     session: z.ZodDefault<z.ZodObject<{
         staleMinutes: z.ZodDefault<z.ZodNumber>;
         maxTurnsPerSession: z.ZodDefault<z.ZodNumber>;
@@ -3445,18 +4037,49 @@ declare const daemonConfigSchema: z.ZodObject<{
      *  default — installs that don't list plugins are unaffected. Plugin
      *  authoring guide: docs/architecture/plugins.md. */
     plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Persistent-process pool eviction knobs (handoff #8). The pool keeps
+     *  one warm Claude subprocess per (agent, channel, chatId) so latency
+     *  stays low; without bounds, an idle process can serve traffic days
+     *  later with stale context. These knobs cap that risk. All values are
+     *  in seconds for operator-friendliness; the registry uses ms internally.
+     *
+     *  - `maxIdleSeconds`: a handle becomes eligible for cap-pressured
+     *    eviction this many seconds after its last turn. Default 30s
+     *    (matches the registry's pre-config behavior).
+     *  - `maxAgeSeconds`: a handle is killed unconditionally on the next
+     *    sweep once its total wall-clock idleness exceeds this. Default
+     *    2700s (45min) — matches the registry's pre-config staleTimeoutMs.
+     *  - `sweepIntervalSeconds`: how often the sweeper checks. Default 5s.
+     *
+     *  See `agents.<id>.persistentProcess` to opt an agent into the pool. */
+    processPool: z.ZodDefault<z.ZodObject<{
+        maxIdleSeconds: z.ZodDefault<z.ZodNumber>;
+        maxAgeSeconds: z.ZodDefault<z.ZodNumber>;
+        sweepIntervalSeconds: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxIdleSeconds: number;
+        maxAgeSeconds: number;
+        sweepIntervalSeconds: number;
+    }, {
+        maxIdleSeconds?: number | undefined;
+        maxAgeSeconds?: number | undefined;
+        sweepIntervalSeconds?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     agents: Record<string, {
         name: string;
         workspace: string;
-        tier: "claude-code" | "sdk" | "orchestrator";
+        tier: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator";
         mentions: string[];
         intents: string[];
         maxDelegationDepth: number;
+        codegraph: boolean;
         contextReferences: boolean;
+        richMessages: boolean;
         maxConcurrent: number;
         maxExecutionMinutes: number;
         permissionMode: string;
+        toolUseRequired: string[];
         persistentProcess: boolean;
         queueMode: "collect" | "followup" | "drop";
         heartbeat: {
@@ -3466,15 +4089,37 @@ declare const daemonConfigSchema: z.ZodObject<{
             intervalMinutes: number;
         };
         access: "private" | "public";
+        integrations: {
+            enabled: boolean;
+            credentials: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            };
+            metadata: Record<string, string | number | boolean>;
+            label: string;
+            kind: string;
+        }[];
         provider?: string | undefined;
         model?: string | undefined;
         systemPrompt?: string | undefined;
         mcp?: Record<string, {
             command: string;
             args: string[];
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
+        } | {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
         }> | undefined;
         contextStrategy?: "layered" | "planner" | undefined;
+        gitlabAutoReply?: boolean | undefined;
     }>;
     mesh: {
         enabled: boolean;
@@ -3510,6 +4155,7 @@ declare const daemonConfigSchema: z.ZodObject<{
     };
     providers: Record<string, {
         apiKey?: string | undefined;
+        thinking?: boolean | undefined;
         defaultModel?: string | undefined;
         baseUrl?: string | undefined;
     }>;
@@ -3522,6 +4168,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             }[];
             webhookPort: number;
             host: string;
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 gitlabUsernames: string[];
@@ -3532,20 +4179,6 @@ declare const daemonConfigSchema: z.ZodObject<{
             token?: string | undefined;
             webhookSecret?: string | undefined;
         };
-        telegram: {
-            enabled: boolean;
-            accounts: Record<string, {
-                token: string;
-                agentBinding: string;
-                pollInbound: boolean;
-                allowFrom?: string[] | undefined;
-            }>;
-            policy: {
-                dm: "block" | "pair";
-                group: "all" | "mention-required";
-                allowFrom?: string[] | undefined;
-            };
-        };
         whatsapp: {
             enabled: boolean;
             sessionDir: string;
@@ -3574,16 +4207,19 @@ declare const daemonConfigSchema: z.ZodObject<{
             allowFrom?: string[] | undefined;
             defaultAgent?: string | undefined;
         };
-        discord: {
-            enabled: boolean;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        };
-        slack: {
+        telegram: {
             enabled: boolean;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
+            accounts: Record<string, {
+                token: string;
+                agentBinding: string;
+                pollInbound: boolean;
+                allowFrom?: string[] | undefined;
+            }>;
+            policy: {
+                dm: "block" | "pair";
+                group: "all" | "mention-required";
+                allowFrom?: string[] | undefined;
+            };
         };
         github: {
             enabled: boolean;
@@ -3591,6 +4227,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 agent: string;
                 repo: string;
             }[];
+            autoReplyLegacy: boolean;
             agentMappings: {
                 agentId: string;
                 githubUsernames: string[];
@@ -3697,7 +4334,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         columns: {
             id: string;
             title: string;
-            kind: "open-backlog" | "scoped-label" | "closed" | "label";
+            kind: "label" | "open-backlog" | "scoped-label" | "closed";
             scopedPrefix: string;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
@@ -3732,12 +4369,35 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows: {
         dir: string;
         enabled: boolean;
+        matching: {
+            enabled: boolean;
+            mode: "auto" | "suggest";
+            autoRunThreshold: number;
+            suggestThreshold: number;
+        };
         editor: "disabled" | "readonly" | "edit";
     };
+    procedures: {
+        dir: string;
+        enabled: boolean;
+        extraction: {
+            enabled: boolean;
+            onTaskCompletion: boolean;
+            minOccurrences: number;
+            sinceDays: number;
+            maxClusters: number;
+            via?: string | undefined;
+        };
+        injection: {
+            enabled: boolean;
+            maxProcedures: number;
+            minScore: number;
+        };
+    };
     webhooks: {
         enabled: boolean;
         id: string;
-        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        source: string;
         agentId: string;
         description?: string | undefined;
         triggers?: Record<string, string> | undefined;
@@ -3754,6 +4414,11 @@ declare const daemonConfigSchema: z.ZodObject<{
         maxClaudeCodeDispatchesPer5h: number;
     };
     plugins: string[];
+    processPool: {
+        maxIdleSeconds: number;
+        maxAgeSeconds: number;
+        sweepIntervalSeconds: number;
+    };
     business?: {
         enabled: boolean;
         projects: {
@@ -3828,21 +4493,30 @@ declare const daemonConfigSchema: z.ZodObject<{
         workspace: string;
         provider?: string | undefined;
         model?: string | undefined;
-        tier?: "claude-code" | "sdk" | "orchestrator" | undefined;
+        tier?: "claude-code" | "codex-cli" | "opencode" | "sdk" | "orchestrator" | undefined;
         systemPrompt?: string | undefined;
         mentions?: string[] | undefined;
         intents?: string[] | undefined;
         maxDelegationDepth?: number | undefined;
         mcp?: Record<string, {
             command: string;
+            type?: "stdio" | undefined;
             env?: Record<string, string> | undefined;
             args?: string[] | undefined;
+        } | {
+            type: "http";
+            url: string;
+            headers?: Record<string, string> | undefined;
         }> | undefined;
+        codegraph?: boolean | undefined;
         contextStrategy?: "layered" | "planner" | undefined;
         contextReferences?: boolean | undefined;
+        richMessages?: boolean | undefined;
         maxConcurrent?: number | undefined;
         maxExecutionMinutes?: number | undefined;
         permissionMode?: string | undefined;
+        toolUseRequired?: string[] | undefined;
+        gitlabAutoReply?: boolean | undefined;
         persistentProcess?: boolean | undefined;
         queueMode?: "collect" | "followup" | "drop" | undefined;
         heartbeat?: {
@@ -3852,6 +4526,22 @@ declare const daemonConfigSchema: z.ZodObject<{
             intervalMinutes?: number | undefined;
         } | undefined;
         access?: "private" | "public" | undefined;
+        integrations?: {
+            label: string;
+            kind: string;
+            enabled?: boolean | undefined;
+            credentials?: {
+                tokenEnv?: string | undefined;
+                privateAppTokenEnv?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                refreshTokenEnv?: string | undefined;
+                clientIdEnv?: string | undefined;
+                clientSecretEnv?: string | undefined;
+                auth?: "keyring" | undefined;
+                sessionDir?: string | undefined;
+            } | undefined;
+            metadata?: Record<string, string | number | boolean> | undefined;
+        }[] | undefined;
     }> | undefined;
     mesh?: {
         enabled?: boolean | undefined;
@@ -3881,6 +4571,7 @@ declare const daemonConfigSchema: z.ZodObject<{
     } | undefined;
     providers?: Record<string, {
         apiKey?: string | undefined;
+        thinking?: boolean | undefined;
         defaultModel?: string | undefined;
         baseUrl?: string | undefined;
     }> | undefined;
@@ -3895,6 +4586,7 @@ declare const daemonConfigSchema: z.ZodObject<{
             webhookPort?: number | undefined;
             webhookSecret?: string | undefined;
             host?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -3903,24 +4595,10 @@ declare const daemonConfigSchema: z.ZodObject<{
                 node?: string | undefined;
             }[] | undefined;
         } | undefined;
-        telegram?: {
-            enabled?: boolean | undefined;
-            accounts?: Record<string, {
-                token: string;
-                agentBinding: string;
-                allowFrom?: string[] | undefined;
-                pollInbound?: boolean | undefined;
-            }> | undefined;
-            policy?: {
-                allowFrom?: string[] | undefined;
-                dm?: "block" | "pair" | undefined;
-                group?: "all" | "mention-required" | undefined;
-            } | undefined;
-        } | undefined;
         whatsapp?: {
             enabled?: boolean | undefined;
-            allowFrom?: string[] | undefined;
             sessionDir?: string | undefined;
+            allowFrom?: string[] | undefined;
             defaultAgent?: string | undefined;
             routes?: {
                 agent: string;
@@ -3945,16 +4623,19 @@ declare const daemonConfigSchema: z.ZodObject<{
                 retentionDays?: number | undefined;
             } | undefined;
         } | undefined;
-        discord?: {
-            enabled?: boolean | undefined;
-            token?: string | undefined;
-            agentBinding?: string | undefined;
-        } | undefined;
-        slack?: {
+        telegram?: {
             enabled?: boolean | undefined;
-            agentBinding?: string | undefined;
-            botToken?: string | undefined;
-            appToken?: string | undefined;
+            accounts?: Record<string, {
+                token: string;
+                agentBinding: string;
+                allowFrom?: string[] | undefined;
+                pollInbound?: boolean | undefined;
+            }> | undefined;
+            policy?: {
+                allowFrom?: string[] | undefined;
+                dm?: "block" | "pair" | undefined;
+                group?: "all" | "mention-required" | undefined;
+            } | undefined;
         } | undefined;
         github?: {
             enabled?: boolean | undefined;
@@ -3964,6 +4645,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 repo: string;
             }[] | undefined;
             webhookSecret?: string | undefined;
+            autoReplyLegacy?: boolean | undefined;
             agentMappings?: {
                 agentId: string;
                 token?: string | undefined;
@@ -4131,7 +4813,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         columns?: {
             id: string;
             title: string;
-            kind?: "open-backlog" | "scoped-label" | "closed" | "label" | undefined;
+            kind?: "label" | "open-backlog" | "scoped-label" | "closed" | undefined;
             mapsToLabel?: string | undefined;
             scopedLabel?: string | undefined;
             scopedPrefix?: string | undefined;
@@ -4165,11 +4847,34 @@ declare const daemonConfigSchema: z.ZodObject<{
     workflows?: {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        matching?: {
+            enabled?: boolean | undefined;
+            mode?: "auto" | "suggest" | undefined;
+            autoRunThreshold?: number | undefined;
+            suggestThreshold?: number | undefined;
+        } | undefined;
         editor?: "disabled" | "readonly" | "edit" | undefined;
     } | undefined;
+    procedures?: {
+        dir?: string | undefined;
+        enabled?: boolean | undefined;
+        extraction?: {
+            enabled?: boolean | undefined;
+            onTaskCompletion?: boolean | undefined;
+            minOccurrences?: number | undefined;
+            sinceDays?: number | undefined;
+            maxClusters?: number | undefined;
+            via?: string | undefined;
+        } | undefined;
+        injection?: {
+            enabled?: boolean | undefined;
+            maxProcedures?: number | undefined;
+            minScore?: number | undefined;
+        } | undefined;
+    } | undefined;
     webhooks?: {
         id: string;
-        source: "custom" | "gitlab" | "discord" | "slack" | "github" | "sentry" | "stripe";
+        source: string;
         agentId: string;
         enabled?: boolean | undefined;
         description?: string | undefined;
@@ -4187,6 +4892,11 @@ declare const daemonConfigSchema: z.ZodObject<{
         maxClaudeCodeDispatchesPer5h?: number | undefined;
     } | undefined;
     plugins?: string[] | undefined;
+    processPool?: {
+        maxIdleSeconds?: number | undefined;
+        maxAgeSeconds?: number | undefined;
+        sweepIntervalSeconds?: number | undefined;
+    } | undefined;
 }>;
 type DaemonConfig = z.infer<typeof daemonConfigSchema>;
 type AgentDef = z.infer<typeof agentConfigSchema>;
@@ -4284,6 +4994,13 @@ declare class A2AMesh {
          *  caller is allowed to act for this agent. Optional during the
          *  log-warn rollout; missing values produce a server-side warning. */
         senderAgentId?: string;
+        /** Force a fresh session on the receiving daemon (clears cached
+         *  claudeSessionId + kills any persistent-process handle keyed
+         *  on the receiver's (agent, channel, chatId) before exec).
+         *  Defaults undefined → receiver applies its own auto-default
+         *  (true when senderAgentId is set, otherwise false). Set
+         *  explicitly to override. */
+        freshSession?: boolean;
         /** 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)
@@ -4294,6 +5011,27 @@ declare class A2AMesh {
          *  2026-04-29 issue #709. Shape matches AgentTask.context. */
         context?: Record<string, unknown>;
     }): Promise<string>;
+    /**
+     * Streaming variant of `sendTask`. POSTs to the peer's `/task` with
+     * `Accept: text/event-stream`, parses the agentx SSE wire (event/data
+     * pairs), and yields `{event, data}` records as they arrive — text
+     * deltas, thinking chunks, tool start/result, and a terminal
+     * `done` (or `error`).
+     *
+     * Same timeout + dispatcher story as sendTask: undici dispatcher with
+     * disabled headersTimeout/bodyTimeout so a multi-minute agent run does
+     * not get killed by the default 300s headers cap, while an
+     * AbortController enforces our own wall-clock.
+     */
+    sendTaskStream(peerName: string, text: string, agentId?: string, opts?: {
+        timeoutMs?: number;
+        senderAgentId?: string;
+        freshSession?: boolean;
+        context?: Record<string, unknown>;
+    }): AsyncGenerator<{
+        event: string;
+        data: any;
+    }>;
     /**
      * Forward a WebRTC signaling message (SDP / ICE / hangup) to a remote peer's
      * /webrtc/signal endpoint. Not gated by peer health — a healthy control plane
@@ -4323,6 +5061,12 @@ declare class A2AMesh {
      * workflow `action.send` to forward outbound messages back to the peer
      * that owns the channel when the workflow runs on a different node.
      */
+    /**
+     * Auth headers for daemon-level fetches to a peer's protected endpoints.
+     * Tokens deliberately never ride along in directory() — it is served to
+     * dashboards and /mesh; look them up per-request by peer name instead.
+     */
+    authHeaders(peerName: string): Record<string, string>;
     directory(): Array<{
         peer: string;
         peerUrl: string;
@@ -4431,12 +5175,17 @@ declare class AgentXDaemon {
     private registry;
     private router;
     private cron;
+    /** Per-project webhook rules. Hot-reloaded from .agentx/projects/.
+     *  Wired into the gitlab/github adapters at startup so they can gate
+     *  events and resolve runbook paths. */
+    private projectRules;
     private mesh?;
     private hooks;
     private landscape;
     private heartbeat;
     private business?;
     private httpServer?;
+    private attachSweep?;
     private webhooks;
     private github?;
     private webrtc?;
@@ -4517,6 +5266,13 @@ declare class AgentXDaemon {
      * The page does getUserMedia, RTCPeerConnection, and POSTs/listens signals.
      */
     private serveCallPage;
+    /** POST endpoints that mesh peers call across the network. Everything
+     *  else on this server is either read-only, loopback-operated (CLI,
+     *  same-host dashboard), or carries its own secret (chat routes). */
+    private static readonly MESH_PROTECTED_PATHS;
+    /** Wraps decideMeshAuth (daemon/mesh-auth.ts) with token collection,
+     *  logging, and the 401 response. */
+    private checkMeshAuth;
     private handleHttp;
     /**
      * OpenAI-compatible chat completions endpoint.
@@ -4531,6 +5287,13 @@ declare class AgentXDaemon {
      */
     private handleOpenAICompat;
     private json;
+    /** Resolve a GitLab API token for the given agent, checking (in order):
+     *    1. `channels.gitlab.agentMappings[].token` — legacy per-agent token
+     *    2. `agents[id].integrations[]` (kind=gitlab-user, tokenEnv) — newer
+     *       style used by agents declared via `agentx manage`
+     *    3. `channels.gitlab.token` — global fallback (group bot identity)
+     *  Returns the token plus a `source` tag for diagnostic logging. */
+    private resolveGitlabTokenForAgent;
     /** Pick today's usage rollup according to AGENTX_USAGE_READ:
      *    - "sqlite": SQLite only (empty if db null / no rows)
      *    - "json":   JSON only (legacy behaviour)
@@ -4558,10 +5321,6 @@ declare class AgentXDaemon {
      *  heavy lifting is in `AgentRegistry.agentMemory` (AgentMemory); this
      *  is a thin JSON wrapper that validates + delegates. */
     private handleMemoryApi;
-    /** Mesh receiver for forwarded workflow events. Peers POST the same
-     *  payload shape the MeshForwarder sends. Enforces that the run is
-     *  actually home'd here before acting — protects against routing loops. */
-    private handleTaskApi;
     private handleWorkflowEvent;
     /** Mesh-callable outbound send. A peer's workflow `action.send` invokes
      *  this when the channel lives on this node (e.g. clawd-server hosts
@@ -4581,6 +5340,13 @@ declare class AgentXDaemon {
      *  `sources` in the response tells the editor where the entries came from
      *  so it can show that metadata alongside. */
     private handleChannelChats;
+    /** Replay a draft as an ad-hoc workflow. The draft itself stays in
+     *  `_drafts/`; we register a copy as `_adhoc-replay-<draftId>-<ts>.yaml`
+     *  in the active store, hot-reload, and fire it through the dispatcher.
+     *  Input is sourced from a trace pulled out of the draft's
+     *  `sourceTaskIds` — caller can override which trace via `taskId` in the
+     *  body, or supply a payload directly via `input`. */
+    private handleWorkflowDraftReplay;
     /** Manual run endpoint used by `agentx workflow run <id>`. Only workflows
      *  whose trigger node is `trigger.manual` are runnable here — any other
      *  source expects a live event and shouldn't race with a manual kick. */
@@ -4764,6 +5530,19 @@ declare class TokenTracker {
     private save;
 }
 
+interface FriendlyError {
+    /** One-line, operator-facing message suitable for a dashboard card or chat reply. */
+    message: string;
+    /** Optional next step the user can take. */
+    fix?: string;
+    /** Machine-readable error category for routing / retries. */
+    kind: "out_of_credits" | "overage_disabled" | "usage_cap" | "auth" | "permission" | "rate_limit" | "overloaded" | "context_too_large" | "invalid_request" | "upstream_api" | "timeout" | "cancelled" | "unknown";
+    /** Whether this error is transient — a retry has a reasonable chance of succeeding. */
+    retryable: boolean;
+    /** Source error text retained for logs / debugging. */
+    raw?: string;
+}
+
 interface AgentPeer {
     id: string;
     name: string;
@@ -4813,6 +5592,21 @@ interface AgentTask {
      *  parser can append rows under the same id. Optional — when unset,
      *  step capture is a no-op. */
     taskId?: string;
+    /** Improvement plan #8 — when true, the dispatcher discards any
+     *  cached session for this (agent, channel, chatId) before
+     *  executing: the claudeSessionId is cleared (no --resume) and
+     *  any persistent-process handle is killed so the next dispatch
+     *  spawns fresh. Use from triage→sub-agent delegation paths where
+     *  the caller knows this is a NEW visitor on a chatId that may
+     *  collide with prior conversations.
+     *
+     *  Caught in benchmark Run 3 (2026-05-04): a triage agent
+     *  delegated to "lead" for a brand-new visitor; lead's warm
+     *  persistent process replied with the previous visitor's
+     *  confirmation message. freshSession: true defends against
+     *  that pattern without requiring callers to invent unique
+     *  chatIds. */
+    freshSession?: boolean;
     context?: {
         channel?: string;
         sender?: string;
@@ -4851,15 +5645,38 @@ interface AgentTask {
             };
             facts?: string[];
         };
+        /** Path to the project root whose runbook (CLAUDE.md / AGENTS.md / etc.)
+         *  should be injected into the agent's system prefix for this task.
+         *  Set by the gitlab/github adapters when a project rule resolves a
+         *  `runbook:` path. Optional. */
+        runbookPath?: string;
+        /** Override list of files to read from runbookPath. Optional. */
+        runbookFiles?: string[];
     };
 }
 interface AgentResponse {
     content: string;
     error?: string;
+    /** Typed discriminator on `error`. Lets dispatchers and workflow nodes
+     *  branch on the failure cause without string-matching the friendly
+     *  message (which is operator-facing prose, not machine input). The
+     *  full FriendlyError taxonomy is in error-map.ts; common ones to
+     *  branch on: `out_of_credits`, `rate_limit`, `auth`, `timeout`. */
+    errorKind?: FriendlyError["kind"];
     tokensUsed?: number;
     duration?: number;
     claudeSessionId?: string;
+    codexSessionId?: string;
+    opencodeSessionId?: string;
     usage?: TokenUsage;
+    /** End-of-turn context size: the LAST API call's (input + cacheRead +
+     *  cacheCreate) inside this turn, captured from the final assistant
+     *  stream event. `usage` above is CUMULATIVE across every call in the
+     *  agentic loop (a tool-heavy turn easily sums to millions via cache
+     *  reads) — only this field reflects how full the conversation context
+     *  actually is, so rotation decisions must use it, never `usage`.
+     *  Undefined on non-streaming paths (result JSON has no per-call data). */
+    contextTokens?: number;
     /** The model Claude actually billed for (from the CLI's init event). When
      *  absent, cost reporting should fall back to the model override / agent
      *  config. Knowing the billed model is what makes cache-aware pricing
@@ -4870,6 +5687,10 @@ interface AgentResponse {
      *  requested agent (the local registry didn't have it). Name of the
      *  peer that actually ran it. */
     viaMesh?: string;
+    /** Set when a live Claude Code session attached to this identity answered
+     *  the task instead of a spawned provider (attach mode). Claude Code
+     *  session id of the terminal that wrote the reply. */
+    viaAttachedSession?: string;
 }
 /** Callback for streaming text deltas */
 type StreamCallback = (delta: string, fullText: string) => void;
@@ -4887,18 +5708,34 @@ interface TokenUsage {
  * Execute a task using the Claude Code CLI (tier: "claude-code").
  * Non-streaming — waits for full response.
  */
-declare function executeClaudeCode(agent: AgentDef, task: AgentTask, historyContext?: string, resumeSessionId?: string): Promise<AgentResponse>;
+declare function executeClaudeCode(agent: AgentDef, task: AgentTask, historyContext?: string, resumeSessionId?: string, abortSignal?: AbortSignal): Promise<AgentResponse>;
+declare function executeOpenCodeCli(agent: AgentDef, task: AgentTask, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void, abortSignal?: AbortSignal): Promise<AgentResponse>;
 /**
  * Execute a task using the Claude Agent SDK (tier: "sdk").
  */
 declare function executeSdk(agent: AgentDef, task: AgentTask, apiKey: string, historyContext?: string): Promise<AgentResponse>;
 /**
  * Execute a task using agentx's own orchestrator (tier: "orchestrator").
+ *
+ * When `onDelta` is supplied, switches from `generate()` (single-shot) to
+ * `generateStream()` and forwards text deltas as they arrive. This is what
+ * lets the daemon's POST /chat?stream=true actually stream Claude/DeepSeek
+ * tokens — without it, the orchestrator returned only after the agentic
+ * loop finished and SSE clients saw `role` then `stop` with no content
+ * between (the failure mode that surfaced on the noqta-public smoke test
+ * after the tier switch).
  */
-declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?: string, historyContext?: string): Promise<AgentResponse>;
+/** Side-channel for reasoning/thinking chunks — distinct from
+ *  StreamCallback so callers can route them to a different UI lane
+ *  (e.g. a collapsible thinking block on noqta.tn, a dimmed terminal
+ *  block in the dashboard) without polluting the visible response. */
+type ThinkingCallback = (text: string) => void;
+declare function executeOrchestrator(agent: AgentDef, task: AgentTask, apiKey?: string, historyContext?: string, onDelta?: StreamCallback, providerOpts?: {
+    thinking?: boolean;
+}, onThinking?: ThinkingCallback, abortSignal?: AbortSignal, onEvent?: (event: any) => void): Promise<AgentResponse>;
 declare function executeTask(agent: AgentDef, task: AgentTask, providers: Record<string, {
     apiKey?: string;
-}>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void): Promise<AgentResponse>;
+}>, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void, abortSignal?: AbortSignal, onThinking?: ThinkingCallback): Promise<AgentResponse>;
 
 interface DriftReport {
     /** 0-1 score: 0 = no drift, 1 = complete drift */
@@ -5041,6 +5878,17 @@ interface IncomingMessage {
         eventId: string;
         decidedBy: string;
     };
+    /** Path to the project root whose runbook (CLAUDE.md / AGENTS.md / etc.)
+     *  the agent should consult for this task. Set by the gitlab/github
+     *  adapters when a project rule resolves a `runbook:` path. The agent
+     *  registry reads the file set into the cacheable system prefix.
+     *  Undefined when no rule matched — agent uses its own workspace's
+     *  CLAUDE.md as before. */
+    runbookPath?: string;
+    /** Override list of files the registry should read from runbookPath.
+     *  Carried alongside the path so per-project customisation applies
+     *  without the registry re-reading the rule. */
+    runbookFiles?: string[];
 }
 interface OutgoingMessage {
     channel: string;
@@ -5061,6 +5909,12 @@ interface OutgoingMessage {
         mimetype?: string;
         fileName?: string;
     };
+    /** URL inline buttons (Phase 1). Telegram renders an inline_keyboard;
+     *  channels without button support ignore them. */
+    buttons?: Array<{
+        label: string;
+        url: string;
+    }>;
 }
 interface ChannelAdapter {
     readonly name: string;
@@ -5127,6 +5981,8 @@ interface Session {
     chatId: string;
     day: string;
     claudeSessionId?: string;
+    codexSessionId?: string;
+    opencodeSessionId?: string;
     messages: SessionMessage[];
     createdAt: string;
     updatedAt: string;
@@ -5135,11 +5991,24 @@ interface Session {
      *  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. */
+    /** CUMULATIVE billable input of the LAST turn on this claudeSessionId
+     *  (inputTokens + cacheReadTokens + cacheCreateTokens summed across every
+     *  API call in the agentic loop). Kept for observability/billing only —
+     *  a tool-heavy turn sums to millions via cache reads, so this must NOT
+     *  drive rotation decisions. See lastTurnContextTokens. */
     lastTurnInputTokens?: number;
+    /** End-of-turn CONTEXT size: the last API call's (input + cacheRead +
+     *  cacheCreate) inside the previous turn — how full the conversation
+     *  window actually is. This is the tier-2 rotation metric. Absent when
+     *  the turn ran through a non-streaming path (no per-call usage). */
+    lastTurnContextTokens?: number;
+}
+/** Continuity memo captured from a dying session at rotation time —
+ *  injected deterministically into the chat's next fresh session. */
+interface RotationMemoRecord {
+    memo: string;
+    reason: string;
+    capturedAt: string;
 }
 declare class SessionStore {
     private sessionsDir;
@@ -5190,6 +6059,10 @@ declare class SessionStore {
      * Get or create a session for this agent+channel+chat+day.
      */
     getSession(agentId: string, channel: string, chatId: string): Session;
+    /** Yesterday's (UTC) session record for the same triple, or null. Only
+     *  one day back — a gap of 2+ days is stale at any sane staleMinutes,
+     *  so scanning further would never change the outcome. */
+    private loadPreviousDaySession;
     /**
      * 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,
@@ -5197,6 +6070,14 @@ declare class SessionStore {
      * replayed history and re-burns tokens on every subsequent turn.
      */
     addUserMessage(agentId: string, channel: string, chatId: string, senderName: string, content: string): void;
+    /**
+     * Pop the last user message if it matches `expectedContent` (exact equality
+     * after trim). Used by the operator Update flow when Stop was pressed
+     * first — the cancelled user turn has no agent reply, so leaving it in
+     * history makes the next Update read as a bare orphan ask. Match guard
+     * prevents removing something a concurrent path just added.
+     */
+    removeLastUserMessageIfMatches(agentId: string, channel: string, chatId: string, expectedContent: string): boolean;
     /**
      * Add an agent response to the session. Same dedup rule as user messages —
      * retries and duplicate responses shouldn't be replayed on every turn.
@@ -5211,12 +6092,19 @@ declare class SessionStore {
      * Store the Claude Code session ID after first invocation.
      */
     setClaudeSessionId(agentId: string, channel: string, chatId: string, claudeSessionId: string): void;
+    getCodexSessionId(agentId: string, channel: string, chatId: string): string | undefined;
+    setCodexSessionId(agentId: string, channel: string, chatId: string, codexSessionId: string): void;
+    getOpenCodeSessionId(agentId: string, channel: string, chatId: string): string | undefined;
+    setOpenCodeSessionId(agentId: string, channel: string, chatId: string, opencodeSessionId: 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;
+    buildHistoryContext(agentId: string, channel: string, chatId: string, opts?: {
+        maxMessages?: number;
+        maxChars?: number;
+    }): string;
     /**
      * Recall conversation turns across multiple stored sessions for an agent.
      *
@@ -5288,7 +6176,7 @@ declare class SessionStore {
         sessionFile: string;
     }>;
     /**
-     * Check if a Claude session is stale (idle too long for --resume to be useful).
+     * Check if a native CLI 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;
@@ -5320,35 +6208,57 @@ declare class SessionStore {
      */
     hasCompaction(agentId: string, channel: string, chatId: string): boolean;
     /**
-     * Clear the stored Claude session ID so next invocation starts fresh.
+     * Clear stored native CLI session IDs 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.
+     * those are only meaningful relative to the current native session.
      */
     clearClaudeSessionId(agentId: string, channel: string, chatId: string): void;
+    /**
+     * Reset the entire AgentX-side conversation for a delegated fresh session.
+     * Claude needs the native session id cleared; Codex and other non-native
+     * runtimes also need the rendered message history removed or they will see
+     * stale turns through buildHistoryContext().
+     */
+    clearSession(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.
+     * Check whether the LAST turn left the conversation context near the
+     * tier-2 boundary. Uses `lastTurnContextTokens` (the final API call's
+     * per-request input — the true context size) when the runtime captured
+     * it; falls back to the cumulative turn total only when it didn't.
+     * The cumulative number sums cache reads across every call in an
+     * agentic turn (easily 10-20× the real context), so preferring the
+     * per-call metric is what stops rotation from firing on every
+     * tool-heavy turn — the "agent forgets mid-task" bug.
      */
     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.
+     * Called after a successful native CLI response returns with usage info.
+     * `contextTokens` is the end-of-turn per-request context size (see
+     * AgentResponse.contextTokens); undefined on non-streaming paths.
      */
     recordTurnUsage(agentId: string, channel: string, chatId: string, usage: {
         inputTokens: number;
         outputTokens: number;
         cacheReadTokens: number;
         cacheCreateTokens: number;
-    }): void;
+    }, contextTokens?: number): void;
+    private rotationMemoFile;
+    private readRotationMemos;
+    setRotationMemo(agentId: string, channel: string, chatId: string, memo: string, reason: string): void;
+    /** Latest memo for this chat, or null when absent/expired (7-day TTL). */
+    getRotationMemo(agentId: string, channel: string, chatId: string): RotationMemoRecord | null;
     /** Diagnostic getters — used by registry logging. */
     getTurnCount(agentId: string, channel: string, chatId: string): number;
     getLastTurnInputTokens(agentId: string, channel: string, chatId: string): number;
+    /** The rotation metric shouldRotateByTierTwo actually used: per-request
+     *  context size when available, else the cumulative fallback. */
+    getLastTurnContextTokens(agentId: string, channel: string, chatId: string): number;
     getMaxTurnsPerSession(): number;
     getTierTwoThresholdTokens(): number;
     /**
@@ -5975,10 +6885,10 @@ declare const classificationSchema: z.ZodObject<{
         input?: string | undefined;
     };
     channel?: string | undefined;
+    preview?: string | undefined;
     agentId?: string | undefined;
     sender?: string | undefined;
     confidence?: number | undefined;
-    preview?: string | undefined;
 }, {
     path: string[];
     status: "pending" | "approved" | "rejected";
@@ -5986,6 +6896,7 @@ declare const classificationSchema: z.ZodObject<{
     ts: string;
     msgHash: string;
     channel?: string | undefined;
+    preview?: string | undefined;
     agentId?: string | undefined;
     sender?: string | undefined;
     proposedAxes?: Record<string, Record<string, string>> | undefined;
@@ -5994,7 +6905,6 @@ declare const classificationSchema: z.ZodObject<{
         input?: string | undefined;
     } | undefined;
     confidence?: number | undefined;
-    preview?: string | undefined;
 }>;
 type Classification = z.infer<typeof classificationSchema>;
 /** Row in the fingerprint → path snap cache. */
@@ -6014,16 +6924,16 @@ declare const fingerprintEntrySchema: z.ZodObject<{
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     path: string[];
+    updatedAt: string;
     leaf: {
         output?: string | undefined;
         input?: string | undefined;
     };
     fingerprint: string;
-    updatedAt: string;
 }, {
     path: string[];
-    fingerprint: string;
     updatedAt: string;
+    fingerprint: string;
     leaf?: {
         output?: string | undefined;
         input?: string | undefined;
@@ -6101,16 +7011,16 @@ declare const indexFileSchema: z.ZodObject<{
         updatedAt: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         path: string[];
+        updatedAt: string;
         leaf: {
             output?: string | undefined;
             input?: string | undefined;
         };
         fingerprint: string;
-        updatedAt: string;
     }, {
         path: string[];
-        fingerprint: string;
         updatedAt: string;
+        fingerprint: string;
         leaf?: {
             output?: string | undefined;
             input?: string | undefined;
@@ -6119,19 +7029,19 @@ declare const indexFileSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     entries: Record<string, {
         path: string[];
+        updatedAt: string;
         leaf: {
             output?: string | undefined;
             input?: string | undefined;
         };
         fingerprint: string;
-        updatedAt: string;
     }>;
     version: number;
 }, {
     entries?: Record<string, {
         path: string[];
-        fingerprint: string;
         updatedAt: string;
+        fingerprint: string;
         leaf?: {
             output?: string | undefined;
             input?: string | undefined;
@@ -6427,6 +7337,13 @@ declare class AgentRegistry {
      *  the requested agent before returning "Unknown agent". Duck-typed so
      *  we don't create a circular import with src/a2a/mesh.ts. */
     private meshFallback?;
+    /** Workflow auto-runner — invoked when workflow matching is in `mode: "auto"`
+     *  and a candidate workflow's confidence ≥ autoRunThreshold. Wired by the
+     *  daemon after the workflow dispatcher is constructed. Returns the runId of
+     *  the started workflow run; the workflow itself owns posting any reply via
+     *  its `action.send` / `agent` nodes. Duck-typed to avoid a circular import
+     *  on WorkflowDispatcher. */
+    private workflowAutoRunner?;
     private messageQueue;
     /** Intent Knowledge Graph classifier. Null when graph.enabled=false. */
     private classifier?;
@@ -6437,6 +7354,15 @@ declare class AgentRegistry {
     private activeSouls;
     /** Live output captured per running task id — drives the dashboard streaming modal. */
     private taskOutputs;
+    /** Per-running-task AbortController. Set when execution starts, removed in
+     *  finally. Cancel paths (operator stop / replace) call .abort() and the
+     *  runtime kills the underlying claude subprocess.
+     *
+     *  `originalMessage` is the user text recorded in SessionStore at the start
+     *  of this run. When the operator presses Stop first then Update, we use it
+     *  to drop the orphan cancelled turn from history so the Update reads as an
+     *  edit, not a bare follow-up. */
+    private taskAborts;
     /** Last completed task summary per agent — single-line blurb for the dashboard card. */
     private lastSummaries;
     /** 24-hour sparkline cache per agent — recomputed from disk at most once a minute. */
@@ -6456,6 +7382,10 @@ declare class AgentRegistry {
      *  agent this node doesn't have. Called by the daemon after mesh boot.
      *  Pass `undefined` to disable fallback (testing, mesh disabled). */
     setMeshFallback(mesh: NonNullable<AgentRegistry["meshFallback"]>): void;
+    /** Wire the workflow auto-runner — see field doc above. Daemon calls this
+     *  after WorkflowDispatcher boot. Pass undefined to detach (e.g. during
+     *  reload). */
+    setWorkflowAutoRunner(runner: NonNullable<AgentRegistry["workflowAutoRunner"]> | undefined): void;
     /** Hot-swap the provider map. Daemon reload calls this after agentx.json
      *  changes — the next task that executes will resolve credentials through
      *  the fresh table (see executeTask call-site). In-flight tasks keep the
@@ -6533,7 +7463,7 @@ declare class AgentRegistry {
      * this, every dispatched decision sits in-flight forever and the
      * active-task check becomes vacuously over-aggressive.
      */
-    execute(task: AgentTask, onDelta?: StreamCallback): Promise<AgentResponse>;
+    execute(task: AgentTask, onDelta?: StreamCallback, onThinking?: ThinkingCallback, onEvent?: (event: any) => void): Promise<AgentResponse>;
     /**
      * Internal dispatcher — the real body. See `execute` for the public
      * wrapper that adds intent-ledger resolution recording.
@@ -6596,6 +7526,47 @@ declare class AgentRegistry {
      */
     getTaskRecord(agentId: string, taskId: string): TaskRecord | null;
     private safe;
+    /**
+     * Post a queued message's response back to its originating channel.
+     * Used by the flush block in `execute()` — channel messages that arrive
+     * while the agent is busy are queued and re-dispatched here, bypassing
+     * the router; without this helper the agent's reply would never reach
+     * the user. Skipped silently for internal channels (`test`, `api`,
+     * `a2a`, `cron`, `workflow`, …) where no adapter is registered.
+     */
+    private postQueuedResponseToChannel;
+    /**
+     * Operator stop. Aborts the in-flight run for `taskId` (kills the
+     * underlying claude subprocess via the AbortSignal threaded through
+     * runtime.ts). Returns the task's identity for HTTP / audit callers,
+     * or null when no live run matches.
+     */
+    cancelRunningTask(taskId: string, reason?: string): {
+        agentId: string;
+        channel: string;
+        chatId: string;
+    } | null;
+    /**
+     * Queue a follow-up correction/update for an in-flight task. The message
+     * lands in the per-session MessageQueue and is dispatched after the
+     * current run finishes — same path channel messages take while the agent
+     * is busy. With `replace=true` we cancel the current run first so the
+     * follow-up runs immediately.
+     *
+     * Returns the resolved identity + queue position, or null when no live
+     * run matches taskId.
+     */
+    queueFollowUp(taskId: string, message: string, sender: string, opts?: {
+        replace?: boolean;
+        reason?: string;
+    }): {
+        agentId: string;
+        channel: string;
+        chatId: string;
+        replaced: boolean;
+        edited: boolean;
+        pending: number;
+    } | null;
     /**
      * Subscribe to live output for a running task. Returns the buffer that has
      * accumulated so far plus an unsubscribe handle. If the task is unknown,
@@ -7400,6 +8371,7 @@ declare class KPI {
     recordBlocker(agentId: string): void;
     private recomputeUtil;
     private persist;
+    private writeStats;
     flush(): void;
     snapshot(): DailyStats;
     /** Markdown summary for end-of-day main-channel post. */
@@ -7501,6 +8473,12 @@ declare class MessageRouter {
      * file is pruned to only live TTL entries before each write.
      */
     private recentMessageIds;
+    private activeMessageKeys;
+    /** Outbound idempotency table — opt-in via sendOutbound(opts.idempotencyKey).
+     *  Key: `channel|chatId|hash-or-key`. Value: { postedAt epochMs, messageId }.
+     *  Bounded growth — coarse "drop oldest 10%" sweep when over the cap. */
+    private sendDedupeMap;
+    private readonly SEND_DEDUPE_MAX;
     private readonly MESSAGE_ID_TTL_MS;
     private readonly MESSAGE_ID_MAX_ENTRIES;
     private readonly DEDUP_STORE_PATH;
@@ -7542,9 +8520,24 @@ declare class MessageRouter {
      * Used for agent-initiated messages, cron notifications, cross-channel routing.
      *
      * If accountId is not provided for Telegram, auto-resolves from agentId binding.
+     *
+     * `opts.idempotencyKey` — when set, the router caches the (channel,chatId,key)
+     *  tuple for `dedupeWindowMs` (default 60s) and returns the cached messageId
+     *  for repeat calls within the window. The default key is a sha256 of the
+     *  body so an agent that re-runs the same `channel.reply` tool call doesn't
+     *  produce duplicate comments — the canonical fix for the raw-curl-twice
+     *  scenario diagnosed on MR #236 (2026-05-08).
+     *
+     *  Why here and not in the adapter: the router is the single funnel for
+     *  agent + cron + API + cross-channel sends. Workflow `action.send` lives
+     *  at a different abstraction (explicit, scripted, retry semantics owned
+     *  by the engine) so it intentionally stays on the direct adapter path.
      */
     sendOutbound(msg: OutgoingMessage & {
         accountId?: string;
+    }, opts?: {
+        idempotencyKey?: string;
+        dedupeWindowMs?: number;
     }): Promise<string | void>;
     /** List registered channel names. */
     getChannelNames(): string[];
@@ -7561,6 +8554,7 @@ declare class MessageRouter {
      * Stamps the key when false. Size-bounded GC avoids unbounded growth.
      */
     private isDuplicateMessage;
+    private messageKey;
     /**
      * Phase 1 commit 6.b — record one router decision in the intent ledger
      * when the source is enabled (mode != "off"). Covers all router
@@ -7591,7 +8585,18 @@ declare class MessageRouter {
      * Works on Telegram (multi-account), WhatsApp (shared number), Discord.
      */
     private handleBotToBotChain;
+    private sendDedupeKey;
+    private sendDedupeGet;
+    private sendDedupeStore;
     private adapterSend;
+    /** Whether an agent may emit rich `agentx:ui` messages on this channel.
+     *  Gated by per-agent `richMessages` (default true) and restricted to the
+     *  interactive chat channels that render buttons/polls natively. */
+    private richMessagesAllowed;
+    /** Attach directive extras to a just-delivered reply: buttons onto the last
+     *  text message (edit reply_markup), poll + media as follow-up messages.
+     *  Best-effort — a failure here never breaks the text reply. */
+    private attachUiExtras;
     private adapterEdit;
     private adapterReact;
     private startTypingLoop;
@@ -7646,6 +8651,7 @@ declare class TelegramAdapter implements ChannelAdapter {
      *  or its token changes, so its pollLoop observes the stop and exits without
      *  affecting siblings. Keyed by accountId. */
     private accountPolling;
+    private accountVerifyRetryTimers;
     private log;
     /** Global allowlist fallback. When a per-account allowFrom is unset,
      *  this list applies. When BOTH are unset, everything is rejected
@@ -7670,6 +8676,7 @@ declare class TelegramAdapter implements ChannelAdapter {
      *  the bot's identity, then spawns the long-poll loop. No-op if the account
      *  is already polling. */
     private startAccount;
+    private scheduleVerifyRetry;
     /** Stop a single account's poll loop without touching siblings. Flips the
      *  per-account gate and aborts the in-flight long-poll so Telegram releases
      *  the server-side session immediately (otherwise a new start with the same
@@ -7720,6 +8727,12 @@ declare class TelegramAdapter implements ChannelAdapter {
     send(msg: OutgoingMessage & {
         accountId?: string;
     }): Promise<string>;
+    /** Add/replace inline URL buttons on an existing message (editMessageReplyMarkup).
+     *  Used to attach an agentx:ui button row to a streamed reply. Best-effort. */
+    setMessageButtons(chatId: string, messageId: string, buttons: Array<{
+        label: string;
+        url: string;
+    }>, accountId?: string): Promise<boolean>;
     /** 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
@@ -7745,6 +8758,12 @@ declare class TelegramAdapter implements ChannelAdapter {
         accountId?: string;
         parseMode?: "markdown" | "html" | "plain";
     }): Promise<string>;
+    /** Build a Telegram inline_keyboard reply_markup from URL buttons (one row
+     *  per button). Shared by sendWithInlineButtons and send()'s `buttons`. */
+    private inlineKeyboardMarkup;
+    /** Send a single (already chunk-sized) message with optional reply_markup,
+     *  with the standard HTML→plain parse-mode fallback. Returns message id. */
+    private sendOneWithMarkup;
     /**
      * Edit an existing message (for streaming updates).
      */
@@ -8176,4 +9195,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$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 };
+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, executeOpenCodeCli, 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 };