agentix-cli 0.25.0 → 0.27.0

package/dist/index.d.ts

@@ -29,6 +29,31 @@ interface ProviderOptions {
      *  marks the task aborted in the registry; the underlying request
      *  can hang for hours waiting for the model to finish thinking. */
     abortSignal?: AbortSignal;
+    /** Force the model to call one specific tool, making its whole reply the
+     *  tool's structured `input`. Anthropic renders this as
+     *  `tool_choice: {type:"tool", name}`; OpenAI as
+     *  `tool_choice: {type:"function", function:{name}}`. Providers that
+     *  can't force a tool (the claude-code CLI on OAuth) ignore it — callers
+     *  must check `PROVIDER_CAPABILITIES[name].structuredOutput` first. */
+    toolChoice?: {
+        type: "tool";
+        name: string;
+    };
+    /** OpenAI-compatible structured-output passthrough. Anthropic ignores it;
+     *  use `toolChoice` there instead. */
+    responseFormat?: {
+        type: "json_schema";
+        name: string;
+        schema: Record<string, unknown>;
+    };
+    /** Ask for the token distribution behind the answer. Only meaningful on
+     *  OpenAI-compatible providers, and only useful when the answer is a
+     *  single token — see src/decisions/backends/local-llm.ts, which is the
+     *  one caller that has a use for it. */
+    logprobs?: {
+        enabled: true;
+        topK: number;
+    };
 }
 type StreamEvent = {
     type: "text_delta";
@@ -423,12 +448,12 @@ declare function getLegacyTools(): Array<{
 declare function formatToolsForSystemPrompt(): string;
 declare const ALL_TOOL_NAMES: string[];
 
-interface NoqtaToolContext {
-    /** The noqta.tn user UUID this tool call impersonates. */
+interface AcmeToolContext {
+    /** The example.com 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. */
+    /** Override the example.com base URL — defaults to ACME_API_URL env or https://example.com. */
     apiUrl?: string;
 }
 
@@ -517,10 +542,10 @@ declare const skillFrontmatterSchema: z.ZodObject<{
     }>, "many">>;
     /** If true, skill is auto-injected into context when triggers match (per-turn) */
     autoInject: z.ZodOptional<z.ZodBoolean>;
-    /** Reference card ids cited by this skill (e.g. "ksi.gitlab.project.ksi-v2").
+    /** Reference card ids cited by this skill (e.g. "initech.gitlab.project.initech-v2").
      *  Audit lint flags FAILING when any id does not resolve. */
     references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    /** Skills this one delegates to (e.g. ksi-cx-email → [hotmail]). Audit lint
+    /** Skills this one delegates to (e.g. initech-cx-email → [hotmail]). Audit lint
      *  flags FAILING when a delegate has no SKILL.md. */
     delegatesTo: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /** Free-form category — used by recipes and audit rules. Common values:
@@ -623,12 +648,12 @@ interface GenerateOptions {
         lintCommand?: string;
         maxAttempts?: number;
     };
-    /** Enables the noqta workspace tool catalog (list_projects, create_task,
+    /** Enables the acme 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
+     *  executor. Without this set, the acme-tools are absent from the
+     *  agent's tool list — keeps non-acme agents clean. The bearer is
      *  read from env at dispatch time and NEVER enters the prompt. */
-    noqtaContext?: NoqtaToolContext;
+    acmeContext?: AcmeToolContext;
     /** 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
@@ -738,12 +763,12 @@ interface ToolExecutorOptions {
     interactive?: boolean;
     overwrite?: boolean;
     dryRun?: boolean;
-    /** When set, noqta-tools (list_projects, create_task, etc.) become
+    /** When set, acme-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
+     *  enters the model's prompt context. Omit to leave acme-tools off
      *  (the agent will see "Unknown tool" if it calls one anyway). */
-    noqtaContext?: NoqtaToolContext;
+    acmeContext?: AcmeToolContext;
     /** 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. */
@@ -1070,7 +1095,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", "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"];
+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:n8n", "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<{
@@ -1512,8 +1537,8 @@ declare const agentConfigSchema: z.ZodObject<{
      *  .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
+     *  is missing. Off by default — flip on for coding agents (globex-v2-coder,
+     *  initech-v2-coder, umbrella-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
@@ -1523,7 +1548,7 @@ declare const agentConfigSchema: z.ZodObject<{
     contextStrategy: z.ZodOptional<z.ZodEnum<["layered", "planner"]>>;
     /** When true, the registry resolves references-recipes for this agent's
      *  workspace and renders a deterministic [Verified References] block at
-     *  priority 4.7. Off by default — flip on per agent (pm-ksi, devops-agent,
+     *  priority 4.7. Off by default — flip on per agent (pm-initech, devops-agent,
      *  etc.) once a `references/` registry exists in the agent's workspace
      *  or repo root. See src/agents/references/. */
     contextReferences: z.ZodDefault<z.ZodBoolean>;
@@ -1603,7 +1628,7 @@ declare const agentConfigSchema: z.ZodObject<{
     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). */
+        /** Human-readable label (e.g. "@cx_bot", "Acme CRM", "alex@example.com"). Unique per (agent, kind). */
         label: z.ZodString;
         credentials: z.ZodDefault<z.ZodObject<{
             /** Env var holding the secret. Uppercase identifier; daemon resolves at use-time. */
@@ -1786,12 +1811,31 @@ declare const agentConfigSchema: z.ZodObject<{
         metadata?: Record<string, string | number | boolean> | undefined;
     }[] | undefined;
 }>;
-declare const cronJobSchema: z.ZodObject<{
+declare const cronJobSchema: z.ZodEffects<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     schedule: z.ZodString;
     timezone: z.ZodDefault<z.ZodString>;
     agent: z.ZodString;
-    prompt: z.ZodString;
+    prompt: z.ZodDefault<z.ZodString>;
+    /**
+     * A shell command to run INSTEAD of dispatching the agent.
+     *
+     * Seven of this fleet's twenty-six crons were a single command wrapped
+     * in an agent, and every one of them carried a paragraph like "Run this
+     * EXACT command. Do NOT substitute, rewrite, shorten, or fall back to
+     * alternative commands." That paragraph is a scar: it exists because
+     * models kept substituting, and no amount of prompt severity makes a
+     * language model a deterministic executor.
+     *
+     * Measured before this existed: ~$0.31 and ~24s per run to execute one
+     * `node script.js` and repeat ten lines of its output — a 114k-token
+     * context for a job with no judgement in it at all.
+     *
+     * When set, the scheduler runs the command directly. No model, no
+     * tokens, no improvisation. `agent` is still required and is who gets
+     * told when it fails.
+     */
+    command: z.ZodOptional<z.ZodString>;
     timeout: z.ZodDefault<z.ZodNumber>;
     model: z.ZodOptional<z.ZodString>;
     /** Soft cap on output length. Claude Code CLI has no hard flag for this,
@@ -1821,6 +1865,7 @@ declare const cronJobSchema: z.ZodObject<{
     timezone: string;
     onError: ("notify" | "log" | "disable")[];
     model?: string | undefined;
+    command?: string | undefined;
     notify?: {
         channel: string;
         chatId: string;
@@ -1828,11 +1873,44 @@ declare const cronJobSchema: z.ZodObject<{
     } | undefined;
     maxOutputTokens?: number | undefined;
 }, {
+    agent: string;
+    schedule: string;
+    model?: string | undefined;
+    enabled?: boolean | undefined;
+    command?: string | undefined;
+    prompt?: string | undefined;
+    timeout?: number | undefined;
+    timezone?: string | undefined;
+    notify?: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    } | undefined;
+    maxOutputTokens?: number | undefined;
+    onError?: "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined;
+}>, {
+    enabled: boolean;
     agent: string;
     prompt: string;
+    timeout: number;
+    schedule: string;
+    timezone: string;
+    onError: ("notify" | "log" | "disable")[];
+    model?: string | undefined;
+    command?: string | undefined;
+    notify?: {
+        channel: string;
+        chatId: string;
+        accountId?: string | undefined;
+    } | undefined;
+    maxOutputTokens?: number | undefined;
+}, {
+    agent: string;
     schedule: string;
     model?: string | undefined;
     enabled?: boolean | undefined;
+    command?: string | undefined;
+    prompt?: string | undefined;
     timeout?: number | undefined;
     timezone?: string | undefined;
     notify?: {
@@ -1960,8 +2038,8 @@ declare const daemonConfigSchema: z.ZodObject<{
          *  .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
+         *  is missing. Off by default — flip on for coding agents (globex-v2-coder,
+         *  initech-v2-coder, umbrella-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
@@ -1971,7 +2049,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         contextStrategy: z.ZodOptional<z.ZodEnum<["layered", "planner"]>>;
         /** When true, the registry resolves references-recipes for this agent's
          *  workspace and renders a deterministic [Verified References] block at
-         *  priority 4.7. Off by default — flip on per agent (pm-ksi, devops-agent,
+         *  priority 4.7. Off by default — flip on per agent (pm-initech, devops-agent,
          *  etc.) once a `references/` registry exists in the agent's workspace
          *  or repo root. See src/agents/references/. */
         contextReferences: z.ZodDefault<z.ZodBoolean>;
@@ -2051,7 +2129,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         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). */
+            /** Human-readable label (e.g. "@cx_bot", "Acme CRM", "alex@example.com"). Unique per (agent, kind). */
             label: z.ZodString;
             credentials: z.ZodDefault<z.ZodObject<{
                 /** Env var holding the secret. Uppercase identifier; daemon resolves at use-time. */
@@ -2485,7 +2563,7 @@ declare const daemonConfigSchema: z.ZodObject<{
                 /** If set, the agent lives on a remote mesh peer (node id). Forces the
                  *  username→agent map to resolve to this mapping even when a local
                  *  agent's token resolves to the same GitLab user — prevents collisions
-                 *  like two agents both claiming @devops-noqta. */
+                 *  like two agents both claiming @devops-acme. */
                 node: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
                 agentId: string;
@@ -2626,6 +2704,37 @@ declare const daemonConfigSchema: z.ZodObject<{
             clientId?: string | undefined;
             privateKeyFile?: string | undefined;
         }>>;
+        /** ntfy push notifications — outbound only. The operator-facing tap on
+         *  the shoulder: cron failures, task errors, and anything an agent decides
+         *  is worth interrupting a human for. `chatId` on an outgoing message is
+         *  the topic; empty falls back to `topic` here. */
+        ntfy: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            /** Self-hosted ntfy base URL. Defaults to the public server. */
+            server: z.ZodDefault<z.ZodString>;
+            /** Default topic. Treat it as a secret — on ntfy.sh, knowing the topic
+             *  is the only thing needed to read or publish to it. */
+            topic: z.ZodOptional<z.ZodString>;
+            /** Access token for protected topics. */
+            token: z.ZodOptional<z.ZodString>;
+            /** 1 (min) .. 5 (max). ntfy's own default is 3. */
+            defaultPriority: z.ZodDefault<z.ZodNumber>;
+            defaultTitle: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            server: string;
+            defaultPriority: number;
+            token?: string | undefined;
+            topic?: string | undefined;
+            defaultTitle?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            token?: string | undefined;
+            server?: string | undefined;
+            topic?: string | undefined;
+            defaultPriority?: number | undefined;
+            defaultTitle?: string | undefined;
+        }>>;
         webrtc: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             /** ICE STUN servers for NAT discovery. Default is Google's public STUN. */
@@ -2866,6 +2975,14 @@ declare const daemonConfigSchema: z.ZodObject<{
             clientId?: string | undefined;
             privateKeyFile?: string | undefined;
         };
+        ntfy: {
+            enabled: boolean;
+            server: string;
+            defaultPriority: number;
+            token?: string | undefined;
+            topic?: string | undefined;
+            defaultTitle?: string | undefined;
+        };
         webrtc: {
             enabled: boolean;
             stunServers: string[];
@@ -2979,6 +3096,14 @@ declare const daemonConfigSchema: z.ZodObject<{
             clientId?: string | undefined;
             privateKeyFile?: string | undefined;
         } | undefined;
+        ntfy?: {
+            enabled?: boolean | undefined;
+            token?: string | undefined;
+            server?: string | undefined;
+            topic?: string | undefined;
+            defaultPriority?: number | undefined;
+            defaultTitle?: string | undefined;
+        } | undefined;
         webrtc?: {
             enabled?: boolean | undefined;
             stunServers?: string[] | undefined;
@@ -3010,12 +3135,31 @@ declare const daemonConfigSchema: z.ZodObject<{
             } | undefined;
         } | undefined;
     }>>;
-    crons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    crons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         schedule: z.ZodString;
         timezone: z.ZodDefault<z.ZodString>;
         agent: z.ZodString;
-        prompt: z.ZodString;
+        prompt: z.ZodDefault<z.ZodString>;
+        /**
+         * A shell command to run INSTEAD of dispatching the agent.
+         *
+         * Seven of this fleet's twenty-six crons were a single command wrapped
+         * in an agent, and every one of them carried a paragraph like "Run this
+         * EXACT command. Do NOT substitute, rewrite, shorten, or fall back to
+         * alternative commands." That paragraph is a scar: it exists because
+         * models kept substituting, and no amount of prompt severity makes a
+         * language model a deterministic executor.
+         *
+         * Measured before this existed: ~$0.31 and ~24s per run to execute one
+         * `node script.js` and repeat ten lines of its output — a 114k-token
+         * context for a job with no judgement in it at all.
+         *
+         * When set, the scheduler runs the command directly. No model, no
+         * tokens, no improvisation. `agent` is still required and is who gets
+         * told when it fails.
+         */
+        command: z.ZodOptional<z.ZodString>;
         timeout: z.ZodDefault<z.ZodNumber>;
         model: z.ZodOptional<z.ZodString>;
         /** Soft cap on output length. Claude Code CLI has no hard flag for this,
@@ -3045,6 +3189,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         timezone: string;
         onError: ("notify" | "log" | "disable")[];
         model?: string | undefined;
+        command?: string | undefined;
         notify?: {
             channel: string;
             chatId: string;
@@ -3052,11 +3197,44 @@ declare const daemonConfigSchema: z.ZodObject<{
         } | undefined;
         maxOutputTokens?: number | undefined;
     }, {
+        agent: string;
+        schedule: string;
+        model?: string | undefined;
+        enabled?: boolean | undefined;
+        command?: string | undefined;
+        prompt?: string | undefined;
+        timeout?: number | undefined;
+        timezone?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        maxOutputTokens?: number | undefined;
+        onError?: "notify" | "log" | "disable" | ("notify" | "log" | "disable")[] | undefined;
+    }>, {
+        enabled: boolean;
         agent: string;
         prompt: string;
+        timeout: number;
+        schedule: string;
+        timezone: string;
+        onError: ("notify" | "log" | "disable")[];
+        model?: string | undefined;
+        command?: string | undefined;
+        notify?: {
+            channel: string;
+            chatId: string;
+            accountId?: string | undefined;
+        } | undefined;
+        maxOutputTokens?: number | undefined;
+    }, {
+        agent: string;
         schedule: string;
         model?: string | undefined;
         enabled?: boolean | undefined;
+        command?: string | undefined;
+        prompt?: string | undefined;
         timeout?: number | undefined;
         timezone?: string | undefined;
         notify?: {
@@ -3201,6 +3379,21 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: string;
             token?: string | undefined;
         }>, "many">>;
+        /** Empty by default — a node publishes no inboxes until an operator
+         *  declares one, so this feature is opt-in per node. */
+        inboxes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            agent: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            agent: string;
+            name: string;
+        }, {
+            agent: string;
+            name: string;
+            enabled?: boolean | undefined;
+        }>, "many">>;
         discovery: z.ZodDefault<z.ZodEnum<["static", "mdns"]>>;
         healthCheck: z.ZodDefault<z.ZodObject<{
             interval: z.ZodDefault<z.ZodNumber>;
@@ -3219,6 +3412,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: string;
             token?: string | undefined;
         }[];
+        inboxes: {
+            enabled: boolean;
+            agent: string;
+            name: string;
+        }[];
         discovery: "static" | "mdns";
         healthCheck: {
             timeout: number;
@@ -3231,6 +3429,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: string;
             token?: string | undefined;
         }[] | undefined;
+        inboxes?: {
+            agent: string;
+            name: string;
+            enabled?: boolean | undefined;
+        }[] | undefined;
         discovery?: "static" | "mdns" | undefined;
         healthCheck?: {
             timeout?: number | undefined;
@@ -3400,6 +3603,22 @@ declare const daemonConfigSchema: z.ZodObject<{
             project?: string | undefined;
             displayName?: string | undefined;
         }>, "many">>;
+        clients: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<["client", "internal", "own"]>>;
+            respondWithin: z.ZodOptional<z.ZodString>;
+            standing: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            standing: string[];
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+        }, {
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+            standing?: string[] | undefined;
+        }>>>;
         workTickMinutes: z.ZodDefault<z.ZodNumber>;
         idleQueueThreshold: z.ZodDefault<z.ZodNumber>;
         standup: z.ZodDefault<z.ZodObject<{
@@ -3471,6 +3690,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             project?: string | undefined;
             displayName?: string | undefined;
         }[];
+        clients: Record<string, {
+            standing: string[];
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+        }>;
         workTickMinutes: number;
         idleQueueThreshold: number;
         standup: {
@@ -3532,6 +3757,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             project?: string | undefined;
             displayName?: string | undefined;
         }[] | undefined;
+        clients?: Record<string, {
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+            standing?: string[] | undefined;
+        }> | undefined;
         workTickMinutes?: number | undefined;
         idleQueueThreshold?: number | undefined;
         standup?: {
@@ -3554,7 +3785,8 @@ declare const daemonConfigSchema: z.ZodObject<{
             type: "gitlab";
             projects: string[];
         }>]>;
-        primaryToolLabel: z.ZodOptional<z.ZodString>;
+        primaryToolLabel: z.ZodOptional<z.ZodString>; /** Non-secret metadata — username, email, host URL, portal id, JID, etc.
+         *  Visible in the dashboard and to skills. */
         labels: z.ZodDefault<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             color: z.ZodDefault<z.ZodString>;
@@ -3803,12 +4035,373 @@ declare const daemonConfigSchema: z.ZodObject<{
             bm25?: number | undefined;
         } | undefined;
     }>>;
+    decisions: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        dbPath: z.ZodDefault<z.ZodString>;
+        /** State can contain message text. With this on, only the hash is kept,
+         *  which costs the ability to replay a decision offline. */
+        redactState: z.ZodDefault<z.ZodBoolean>;
+        /** Keep the serialized state for this many rows per seat, then prune to
+         *  hashes. Enough to replay and to grade an alternative backend on
+         *  identical inputs, without growing without bound. */
+        keepStateRows: z.ZodDefault<z.ZodNumber>;
+        defaultBackend: z.ZodDefault<z.ZodString>;
+        backends: z.ZodDefault<z.ZodObject<{
+            local: z.ZodDefault<z.ZodObject<{
+                provider: z.ZodDefault<z.ZodString>;
+                model: z.ZodDefault<z.ZodString>;
+                /** auto resolves to a forced tool where the provider guarantees one,
+                 *  and JSON-in-text otherwise (claude-code on OAuth cannot force a
+                 *  tool). Never resolves to logprobs: that costs one call per
+                 *  question, so it has to be asked for. */
+                structureMode: z.ZodDefault<z.ZodEnum<["auto", "tool", "text"]>>;
+                normalizeProbabilities: z.ZodDefault<z.ZodBoolean>;
+                nRetryMalformedStructure: z.ZodDefault<z.ZodNumber>;
+                maxStateChars: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                provider: string;
+                model: string;
+                structureMode: "tool" | "text" | "auto";
+                normalizeProbabilities: boolean;
+                nRetryMalformedStructure: number;
+                maxStateChars: number;
+            }, {
+                provider?: string | undefined;
+                model?: string | undefined;
+                structureMode?: "tool" | "text" | "auto" | undefined;
+                normalizeProbabilities?: boolean | undefined;
+                nRetryMalformedStructure?: number | undefined;
+                maxStateChars?: number | undefined;
+            }>>;
+            /** A simple-jev server (featherless-ai/simple-jev). Reads the model's
+             *  next-token logits rather than asking it to write a probability, so
+             *  the distribution is the model's posterior instead of a number it
+             *  chose. Still not calibrated to correctness — that comes from
+             *  `agentx decisions recalibrate`. */
+            simpleJev: z.ZodDefault<z.ZodObject<{
+                baseUrl: z.ZodDefault<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                apiKeyEnv: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxStateChars: z.ZodDefault<z.ZodNumber>;
+                /** Their Choice takes 2-50 candidates, well under Jev's 255. */
+                maxChoiceOptions: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                baseUrl: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+                model?: string | undefined;
+                apiKeyEnv?: string | undefined;
+            }, {
+                model?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            }>>;
+            /** TypeSafe Jev through OpenRouter's alpha decisions endpoint.
+             *  Verified live 2026-09-19 — resolves to typesafe/jev-1.13-20260917,
+             *  provider "TypeSafe", ~0.5s round trip. The id is "jev-latest";
+             *  the namespaced "typesafe/jev-latest" 400s, and neither appears in
+             *  OpenRouter's public model list. Needs OPENROUTER_API_KEY. */
+            jev: z.ZodDefault<z.ZodObject<{
+                baseUrl: z.ZodDefault<z.ZodString>;
+                path: z.ZodDefault<z.ZodString>;
+                model: z.ZodDefault<z.ZodString>;
+                apiKeyEnv: z.ZodDefault<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxStateChars: z.ZodDefault<z.ZodNumber>;
+                maxChoiceOptions: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            }, {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            }>>;
+            /** Jev direct from TypeSafe rather than through OpenRouter. Same
+             *  contract, different billing and rate limits. Needs TYPESAFE_API_KEY. */
+            typesafe: z.ZodDefault<z.ZodObject<{
+                baseUrl: z.ZodDefault<z.ZodString>;
+                path: z.ZodDefault<z.ZodString>;
+                model: z.ZodDefault<z.ZodString>;
+                apiKeyEnv: z.ZodDefault<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxStateChars: z.ZodDefault<z.ZodNumber>;
+                maxChoiceOptions: z.ZodDefault<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            }, {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            local: {
+                provider: string;
+                model: string;
+                structureMode: "tool" | "text" | "auto";
+                normalizeProbabilities: boolean;
+                nRetryMalformedStructure: number;
+                maxStateChars: number;
+            };
+            simpleJev: {
+                baseUrl: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+                model?: string | undefined;
+                apiKeyEnv?: string | undefined;
+            };
+            jev: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+            typesafe: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+        }, {
+            local?: {
+                provider?: string | undefined;
+                model?: string | undefined;
+                structureMode?: "tool" | "text" | "auto" | undefined;
+                normalizeProbabilities?: boolean | undefined;
+                nRetryMalformedStructure?: number | undefined;
+                maxStateChars?: number | undefined;
+            } | undefined;
+            simpleJev?: {
+                model?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            jev?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            typesafe?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+        }>>;
+        seats: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodObject<{
+            /** off: the seat is unreachable. shadow: runs and records, incumbent stays
+             *  authoritative. active: the answer is used. */
+            mode: z.ZodDefault<z.ZodEnum<["off", "shadow", "active"]>>;
+            /** Backend name from the decisions registry. Per-seat, so one seat can be
+             *  graded against a different backend than another at the same time. */
+            backend: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            /** Post-hoc temperature fitted on this seat's own labeled rows. 1 means
+             *  "not calibrated yet", which is where every seat starts — see
+             *  `agentx decisions calibrate`. */
+            temperature: z.ZodDefault<z.ZodNumber>;
+            /** Fraction of would-be-skips to run anyway. Not a tuning knob: a skipped
+             *  decision can never be graded, so without exploration an active seat's
+             *  metrics are computed on the biased sample it selected for itself.
+             *  Setting this to 0 in active mode means the calibration report stops
+             *  being trustworthy the day you promote the seat. */
+            explore: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            temperature: number;
+            mode: "active" | "off" | "shadow";
+            timeoutMs: number;
+            explore: number;
+            model?: string | undefined;
+            backend?: string | undefined;
+        }, {
+            model?: string | undefined;
+            temperature?: number | undefined;
+            backend?: string | undefined;
+            mode?: "active" | "off" | "shadow" | undefined;
+            timeoutMs?: number | undefined;
+            explore?: number | undefined;
+        }>>>>;
+        /** Model routing driven by the task-tier seat.
+         *
+         *  `cheapModel` is the whole switch: with no model named, no task is
+         *  ever routed anywhere. The feature cannot turn itself on, because a
+         *  fleet quietly answering on a smaller model is a regression nobody
+         *  would see in the output. */
+        routing: z.ZodDefault<z.ZodObject<{
+            cheapModel: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            cheapModel?: string | undefined;
+        }, {
+            cheapModel?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        dbPath: string;
+        redactState: boolean;
+        keepStateRows: number;
+        defaultBackend: string;
+        backends: {
+            local: {
+                provider: string;
+                model: string;
+                structureMode: "tool" | "text" | "auto";
+                normalizeProbabilities: boolean;
+                nRetryMalformedStructure: number;
+                maxStateChars: number;
+            };
+            simpleJev: {
+                baseUrl: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+                model?: string | undefined;
+                apiKeyEnv?: string | undefined;
+            };
+            jev: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+            typesafe: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+        };
+        seats: Record<string, {
+            temperature: number;
+            mode: "active" | "off" | "shadow";
+            timeoutMs: number;
+            explore: number;
+            model?: string | undefined;
+            backend?: string | undefined;
+        }>;
+        routing: {
+            cheapModel?: string | undefined;
+        };
+    }, {
+        enabled?: boolean | undefined;
+        dbPath?: string | undefined;
+        redactState?: boolean | undefined;
+        keepStateRows?: number | undefined;
+        defaultBackend?: string | undefined;
+        backends?: {
+            local?: {
+                provider?: string | undefined;
+                model?: string | undefined;
+                structureMode?: "tool" | "text" | "auto" | undefined;
+                normalizeProbabilities?: boolean | undefined;
+                nRetryMalformedStructure?: number | undefined;
+                maxStateChars?: number | undefined;
+            } | undefined;
+            simpleJev?: {
+                model?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            jev?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            typesafe?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+        } | undefined;
+        seats?: Record<string, {
+            model?: string | undefined;
+            temperature?: number | undefined;
+            backend?: string | undefined;
+            mode?: "active" | "off" | "shadow" | undefined;
+            timeoutMs?: number | undefined;
+            explore?: number | undefined;
+        } | undefined> | undefined;
+        routing?: {
+            cheapModel?: string | undefined;
+        } | undefined;
+    }>>;
     /** Workflow engine — declarative state machines that bind channel events
      *  to agents. Off by default; existing installs see no change until
      *  flipped. Definitions live under `dir` (default .agentx/workflows/). */
     workflows: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         dir: z.ZodDefault<z.ZodString>;
+        /** n8n keeps its several hundred connectors; we keep the agents. Point
+         *  this at your n8n and the workflow builder lists YOUR n8n workflows as
+         *  steps, so nobody has to copy a webhook URL by hand. */
+        n8n: z.ZodDefault<z.ZodObject<{
+            baseUrl: z.ZodDefault<z.ZodString>;
+            apiKey: z.ZodDefault<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            apiKey: string;
+            baseUrl: string;
+        }, {
+            apiKey?: string | undefined;
+            baseUrl?: string | undefined;
+        }>>;
         matching: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             mode: z.ZodDefault<z.ZodEnum<["suggest", "auto"]>>;
@@ -3832,6 +4425,10 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         dir: string;
         enabled: boolean;
+        n8n: {
+            apiKey: string;
+            baseUrl: string;
+        };
         matching: {
             enabled: boolean;
             mode: "auto" | "suggest";
@@ -3842,6 +4439,10 @@ declare const daemonConfigSchema: z.ZodObject<{
     }, {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        n8n?: {
+            apiKey?: string | undefined;
+            baseUrl?: string | undefined;
+        } | undefined;
         matching?: {
             enabled?: boolean | undefined;
             mode?: "auto" | "suggest" | undefined;
@@ -4014,6 +4615,17 @@ declare const daemonConfigSchema: z.ZodObject<{
          *  Raise for Max 20×, lower if your workload stays under the cap naturally. */
         maxClaudeCodeDispatchesPerHour: z.ZodDefault<z.ZodNumber>;
         maxClaudeCodeDispatchesPer5h: z.ZodDefault<z.ZodNumber>;
+        /** How many requests BEFORE the immediate predecessor to show the
+         *  session-continuity seat. 0 keeps today's two-message state exactly.
+         *
+         *  Off by default on purpose. A probe over 27 hand-written turns found
+         *  that at 3, the seat's safety question (`needsHistory`) becomes
+         *  cleanly separable where two messages leave it straddling zero — but
+         *  that rests on 7 positive examples from synthetic scenarios, and this
+         *  seat's failure mode is the agent silently losing conversation
+         *  context. The promotion gate for that wants labelled production rows,
+         *  not a good afternoon on a fixture. Raise it to collect them. */
+        continuityStateTurns: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         contextStrategy: "layered" | "planner";
         staleMinutes: number;
@@ -4021,6 +4633,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         tierTwoThresholdTokens: number;
         maxClaudeCodeDispatchesPerHour: number;
         maxClaudeCodeDispatchesPer5h: number;
+        continuityStateTurns: number;
     }, {
         contextStrategy?: "layered" | "planner" | undefined;
         staleMinutes?: number | undefined;
@@ -4028,9 +4641,10 @@ declare const daemonConfigSchema: z.ZodObject<{
         tierTwoThresholdTokens?: number | undefined;
         maxClaudeCodeDispatchesPerHour?: number | undefined;
         maxClaudeCodeDispatchesPer5h?: number | undefined;
+        continuityStateTurns?: number | undefined;
     }>>;
     /** Move B — JS/TS plugins. Each entry is an installed npm package name
-     *  (e.g. `agentx-plugin-mattermost` or `@noqta/plugin-mattermost`); the
+     *  (e.g. `agentx-plugin-mattermost` or `@acme/plugin-mattermost`); the
      *  loader does a dynamic `import(name)` at boot, validates the manifest,
      *  and calls plugin.setup(ctx). Plugins can register channel adapters
      *  via ctx.addChannel() and subscribe to bus events via ctx.on(). Empty
@@ -4128,6 +4742,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: string;
             token?: string | undefined;
         }[];
+        inboxes: {
+            enabled: boolean;
+            agent: string;
+            name: string;
+        }[];
         discovery: "static" | "mdns";
         healthCheck: {
             timeout: number;
@@ -4242,6 +4861,14 @@ declare const daemonConfigSchema: z.ZodObject<{
             clientId?: string | undefined;
             privateKeyFile?: string | undefined;
         };
+        ntfy: {
+            enabled: boolean;
+            server: string;
+            defaultPriority: number;
+            token?: string | undefined;
+            topic?: string | undefined;
+            defaultTitle?: string | undefined;
+        };
         webrtc: {
             enabled: boolean;
             stunServers: string[];
@@ -4282,6 +4909,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         timezone: string;
         onError: ("notify" | "log" | "disable")[];
         model?: string | undefined;
+        command?: string | undefined;
         notify?: {
             channel: string;
             chatId: string;
@@ -4366,9 +4994,67 @@ declare const daemonConfigSchema: z.ZodObject<{
         token?: string | undefined;
         draftAgent?: string | undefined;
     };
+    decisions: {
+        enabled: boolean;
+        dbPath: string;
+        redactState: boolean;
+        keepStateRows: number;
+        defaultBackend: string;
+        backends: {
+            local: {
+                provider: string;
+                model: string;
+                structureMode: "tool" | "text" | "auto";
+                normalizeProbabilities: boolean;
+                nRetryMalformedStructure: number;
+                maxStateChars: number;
+            };
+            simpleJev: {
+                baseUrl: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+                model?: string | undefined;
+                apiKeyEnv?: string | undefined;
+            };
+            jev: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+            typesafe: {
+                model: string;
+                path: string;
+                baseUrl: string;
+                apiKeyEnv: string;
+                timeoutMs: number;
+                maxStateChars: number;
+                maxChoiceOptions: number;
+            };
+        };
+        seats: Record<string, {
+            temperature: number;
+            mode: "active" | "off" | "shadow";
+            timeoutMs: number;
+            explore: number;
+            model?: string | undefined;
+            backend?: string | undefined;
+        }>;
+        routing: {
+            cheapModel?: string | undefined;
+        };
+    };
     workflows: {
         dir: string;
         enabled: boolean;
+        n8n: {
+            apiKey: string;
+            baseUrl: string;
+        };
         matching: {
             enabled: boolean;
             mode: "auto" | "suggest";
@@ -4412,6 +5098,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         tierTwoThresholdTokens: number;
         maxClaudeCodeDispatchesPerHour: number;
         maxClaudeCodeDispatchesPer5h: number;
+        continuityStateTurns: number;
     };
     plugins: string[];
     processPool: {
@@ -4472,6 +5159,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             project?: string | undefined;
             displayName?: string | undefined;
         }[];
+        clients: Record<string, {
+            standing: string[];
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+        }>;
         workTickMinutes: number;
         idleQueueThreshold: number;
         standup: {
@@ -4550,6 +5243,11 @@ declare const daemonConfigSchema: z.ZodObject<{
             url: string;
             token?: string | undefined;
         }[] | undefined;
+        inboxes?: {
+            agent: string;
+            name: string;
+            enabled?: boolean | undefined;
+        }[] | undefined;
         discovery?: "static" | "mdns" | undefined;
         healthCheck?: {
             timeout?: number | undefined;
@@ -4658,6 +5356,14 @@ declare const daemonConfigSchema: z.ZodObject<{
             clientId?: string | undefined;
             privateKeyFile?: string | undefined;
         } | undefined;
+        ntfy?: {
+            enabled?: boolean | undefined;
+            token?: string | undefined;
+            server?: string | undefined;
+            topic?: string | undefined;
+            defaultPriority?: number | undefined;
+            defaultTitle?: string | undefined;
+        } | undefined;
         webrtc?: {
             enabled?: boolean | undefined;
             stunServers?: string[] | undefined;
@@ -4691,10 +5397,11 @@ declare const daemonConfigSchema: z.ZodObject<{
     } | undefined;
     crons?: Record<string, {
         agent: string;
-        prompt: string;
         schedule: string;
         model?: string | undefined;
         enabled?: boolean | undefined;
+        command?: string | undefined;
+        prompt?: string | undefined;
         timeout?: number | undefined;
         timezone?: string | undefined;
         notify?: {
@@ -4788,6 +5495,12 @@ declare const daemonConfigSchema: z.ZodObject<{
             project?: string | undefined;
             displayName?: string | undefined;
         }[] | undefined;
+        clients?: Record<string, {
+            name?: string | undefined;
+            kind?: "client" | "internal" | "own" | undefined;
+            respondWithin?: string | undefined;
+            standing?: string[] | undefined;
+        }> | undefined;
         workTickMinutes?: number | undefined;
         idleQueueThreshold?: number | undefined;
         standup?: {
@@ -4844,9 +5557,67 @@ declare const daemonConfigSchema: z.ZodObject<{
         }[] | undefined;
         draftAgent?: string | undefined;
     } | undefined;
+    decisions?: {
+        enabled?: boolean | undefined;
+        dbPath?: string | undefined;
+        redactState?: boolean | undefined;
+        keepStateRows?: number | undefined;
+        defaultBackend?: string | undefined;
+        backends?: {
+            local?: {
+                provider?: string | undefined;
+                model?: string | undefined;
+                structureMode?: "tool" | "text" | "auto" | undefined;
+                normalizeProbabilities?: boolean | undefined;
+                nRetryMalformedStructure?: number | undefined;
+                maxStateChars?: number | undefined;
+            } | undefined;
+            simpleJev?: {
+                model?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            jev?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+            typesafe?: {
+                model?: string | undefined;
+                path?: string | undefined;
+                baseUrl?: string | undefined;
+                apiKeyEnv?: string | undefined;
+                timeoutMs?: number | undefined;
+                maxStateChars?: number | undefined;
+                maxChoiceOptions?: number | undefined;
+            } | undefined;
+        } | undefined;
+        seats?: Record<string, {
+            model?: string | undefined;
+            temperature?: number | undefined;
+            backend?: string | undefined;
+            mode?: "active" | "off" | "shadow" | undefined;
+            timeoutMs?: number | undefined;
+            explore?: number | undefined;
+        } | undefined> | undefined;
+        routing?: {
+            cheapModel?: string | undefined;
+        } | undefined;
+    } | undefined;
     workflows?: {
         dir?: string | undefined;
         enabled?: boolean | undefined;
+        n8n?: {
+            apiKey?: string | undefined;
+            baseUrl?: string | undefined;
+        } | undefined;
         matching?: {
             enabled?: boolean | undefined;
             mode?: "auto" | "suggest" | undefined;
@@ -4890,6 +5661,7 @@ declare const daemonConfigSchema: z.ZodObject<{
         tierTwoThresholdTokens?: number | undefined;
         maxClaudeCodeDispatchesPerHour?: number | undefined;
         maxClaudeCodeDispatchesPer5h?: number | undefined;
+        continuityStateTurns?: number | undefined;
     } | undefined;
     plugins?: string[] | undefined;
     processPool?: {
@@ -4924,20 +5696,36 @@ interface PeerState {
     consecutiveFailures: number;
     /** Last probe error message — surfaced for debugging via /mesh. */
     lastError?: string;
+    /** True once the peer has answered at least one probe in this process.
+     *  Distinguishes "temporarily unreachable node we know hosts these
+     *  agents" from "peer configured but never seen" — only the former is
+     *  worth deferring messages for. */
+    everHealthy: boolean;
 }
 declare class A2AMesh {
     private peers;
     private healthTimer?;
     private config;
     private log;
-    /** Optional callback fired on peer state transitions (recovered /
-     *  lost / skills changed). Daemon wires this to the event bus for
-     *  live operator visibility. */
-    private peerChangeCallback?;
-    /** Register a listener for peer state transitions. Only one listener
-     *  is kept — repeat calls overwrite. Used by the daemon to bridge
-     *  into the EventBus without introducing a circular dependency. */
-    onPeerChange(cb: typeof A2AMesh.prototype.peerChangeCallback): void;
+    /** Listeners fired on peer state transitions (recovered / lost /
+     *  skills changed). The daemon bridges these into the EventBus for
+     *  live operator visibility; the router uses them to replay messages
+     *  it deferred while a peer was unreachable. */
+    private peerChangeCallbacks;
+    /** Register a listener for peer state transitions. Every registered
+     *  listener is called — an earlier single-callback field meant the
+     *  daemon's EventBus bridge silently displaced any other subscriber,
+     *  which is why the router could not learn about peer recovery.
+     *  Used to reach the daemon/router without a circular dependency. */
+    onPeerChange(cb: (event: {
+        peer: string;
+        healthy: boolean;
+        skills: string[];
+        delta: "recovered" | "lost" | "skills-changed";
+    }) => void): void;
+    /** Fan a transition out to every listener. One throwing listener must
+     *  not stop the others or abort the discovery loop. */
+    private emitPeerChange;
     constructor(config: DaemonConfig, log?: (...args: unknown[]) => void);
     /**
      * Start the mesh: discover peers and begin health checks.
@@ -5007,7 +5795,7 @@ declare class A2AMesh {
          *  the sender used, instead of falling back to api/default. Without
          *  this, a GitLab webhook routed across the mesh lands in the
          *  recipient's api:default bucket with no project, no issue id, no
-         *  channelMeta — i.e., the mtgl/hasanah confusion incident on
+         *  channelMeta — i.e., the globex/umbrella confusion incident on
          *  2026-04-29 issue #709. Shape matches AgentTask.context. */
         context?: Record<string, unknown>;
     }): Promise<string>;
@@ -5040,7 +5828,7 @@ declare class A2AMesh {
      *
      * Peer lookup is tolerant: the `to` field comes from whichever daemon
      * originated the signal, which often spells the same node differently
-     * ("MacBook-Local" vs "macbook-local"). Match on a normalized name so config
+     * ("HQ-Local" vs "hq-local"). Match on a normalized name so config
      * drift across sides doesn't break the signaling path.
      */
     sendSignal(peerName: string, signal: unknown): Promise<boolean>;
@@ -5067,6 +5855,18 @@ declare class A2AMesh {
      * dashboards and /mesh; look them up per-request by peer name instead.
      */
     authHeaders(peerName: string): Record<string, string>;
+    /**
+     * Find the peer that hosts `agentId`, including peers that are currently
+     * unreachable but were healthy earlier in this process (their last-known
+     * skill list is retained across a failed probe).
+     *
+     * Routing uses this to tell a genuinely unknown agent apart from one whose
+     * node is simply down: the first is a drop, the second is a deferral.
+     */
+    findAgentPeer(agentId: string): {
+        peer: string;
+        healthy: boolean;
+    } | undefined;
     directory(): Array<{
         peer: string;
         peerUrl: string;
@@ -5193,12 +5993,20 @@ declare class AgentXDaemon {
     private workflowDispatcher?;
     private workflowStore?;
     private workflowRuns?;
+    private wfHealth?;
+    /** Shares the daemon's SQLite handle; absent when running without one. */
+    private _assistant?;
+    private assistantStore;
+    /** Workflow health for the monitor. Cached for a minute: the dashboard
+     *  polls every 15s and dormancy does not change on that timescale. */
+    private workflowHealth;
     private db;
     private loadedPlugins;
     private readonly agentMemory;
     private contacts;
     /** Persistent-claude process registry. Null when no agent has
      *  persistentProcess: true (legacy spawn-per-task path). */
+    private sessionMonitor?;
     private processRegistry;
     /** Unified observability bus. Publishers (workflow engine, mesh,
      *  channels, signals) emit here; subscribers (SSE, CLI, board
@@ -5219,6 +6027,11 @@ declare class AgentXDaemon {
      * reload cron jobs + in-memory config. Channels / agents / mesh changes
      * still require a restart — we log a warning so the operator knows.
      */
+    /** Bring up the typed-decision seat: register in-tree backends, open the
+     *  shadow store, and hand the runtime its config. Best-effort — a seat
+     *  that cannot record still answers, and a seat that cannot answer
+     *  returns null and leaves its call site's existing behaviour alone. */
+    private initDecisions;
     private startConfigWatcher;
     /**
      * Re-read agentx.json, diff against the in-memory config, apply what we
@@ -5323,7 +6136,7 @@ declare class AgentXDaemon {
     private handleMemoryApi;
     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
+     *  this when the channel lives on this node (e.g. peer-server hosts
      *  whatsapp; macbook's workflow forwards here). Just unwraps to the local
      *  router's outbound path so all the same per-account/per-bot resolution
      *  applies. Authentication is currently the mesh token at the network
@@ -5333,20 +6146,13 @@ declare class AgentXDaemon {
      *  every healthy mesh peer that hosts the channel — a channel's "true"
      *  chat list is spread across whichever nodes are actually paired
      *  (e.g. macbook has the channel enabled but WhatsApp Baileys is unpaired,
-     *  while clawd-server is paired; macbook's list is empty but we still want
-     *  the author to pick from clawd-server's cache). Dedup by `id`; the first
+     *  while peer-server is paired; macbook's list is empty but we still want
+     *  the author to pick from peer-server's cache). Dedup by `id`; the first
      *  source with a given id wins.
      *
      *  `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. */
@@ -5677,6 +6483,13 @@ interface AgentResponse {
      *  actually is, so rotation decisions must use it, never `usage`.
      *  Undefined on non-streaming paths (result JSON has no per-call data). */
     contextTokens?: number;
+    /** Agentic-loop iterations the provider took inside THIS user turn, from
+     *  the CLI result event's `num_turns`. Distinct from a conversation turn:
+     *  one user message can cost many of these when the agent chains tools.
+     *  Benchmarks need it to tell "JEV made the agent cheaper" apart from
+     *  "JEV made the agent do less work". Undefined when the provider does
+     *  not report it. */
+    numTurns?: 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
@@ -5709,7 +6522,7 @@ interface TokenUsage {
  * Non-streaming — waits for full response.
  */
 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>;
+declare function executeOpenCodeCli(agent: AgentDef, task: AgentTask, onDelta?: StreamCallback, historyContext?: string, resumeSessionId?: string, onEvent?: (event: any) => void, abortSignal?: AbortSignal, onThinking?: ThinkingCallback): Promise<AgentResponse>;
 /**
  * Execute a task using the Claude Agent SDK (tier: "sdk").
  */
@@ -5722,12 +6535,12 @@ declare function executeSdk(agent: AgentDef, task: AgentTask, apiKey: string, hi
  * 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
+ * between (the failure mode that surfaced on the acme-public smoke test
  * after the tier switch).
  */
 /** 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
+ *  (e.g. a collapsible thinking block on example.com, 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?: {
@@ -5953,7 +6766,7 @@ interface SeededMessage {
     timestamp: string;
     externalId?: string;
     /** Optional channel-side account/bot identity that handled this message
-     *  (e.g., Telegram accountId "noqta_cx_bot"). Captured by adapters that
+     *  (e.g., Telegram accountId "acme_cx_bot"). Captured by adapters that
      *  shadow-log outbound, so seeded history preserves the audit trail of
      *  which bot identity actually sent each line. Renderers may ignore it. */
     accountId?: string;
@@ -6179,6 +6992,15 @@ declare class SessionStore {
      * 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.
      */
+    /**
+     * How long since this session last did anything, in ms.
+     *
+     * Used to reason about whether the provider's prompt cache for it is
+     * still warm — a cold cache changes which model is cheaper, because the
+     * saving from a cached read only exists while the cache exists. Returns
+     * null when there is no native session to resume.
+     */
+    sessionIdleMs(agentId: string, channel: string, chatId: string): number | null;
     isSessionStale(agentId: string, channel: string, chatId: string): boolean;
     /**
      * Build a summary of recent messages from OTHER sessions for the same agent today.
@@ -6394,6 +7216,30 @@ declare class WikiStore {
      * Search articles by keyword. Returns articles the agent can read.
      */
     search(query: string, agentId: string, maxResults?: number): WikiArticle[];
+    /**
+     * findRelevant, then re-ranked by the wiki-rerank seat.
+     *
+     * Recall comes from findRelevant rather than search() because
+     * findRelevant is the function everything actually calls — search()
+     * turned out to have no callers at all. Additive on purpose: the
+     * synchronous findRelevant is untouched and its existing callers stay
+     * as they are. Measured on the 12-query eval against this
+     * wiki, re-ranking moves R@1 from 33.3% to 50.0% and R@3 from 41.7% to
+     * 66.7%, for about $0.0005 and 550ms a query.
+     *
+     * Fail-open in every direction. Seat off, backend down, no key, fewer
+     * than two candidates — all return BM25's own order, which is what the
+     * caller would have got anyway.
+     *
+     * Note what this cannot do: it only reorders what BM25 shortlisted. In
+     * the eval R@3 sat exactly on that ceiling, so every remaining miss was
+     * an article BM25 never returned. Widening the shortlist does not fix
+     * that — past 30 the extra candidates measurably diluted the ranking.
+     */
+    findRelevantReranked(query: string, agentId?: string, maxResults?: number, opts?: {
+        shortlist?: number;
+        excerptChars?: number;
+    }): Promise<WikiArticle[]>;
     /**
      * Find articles relevant to a message (for context injection).
      *
@@ -6887,8 +7733,8 @@ declare const classificationSchema: z.ZodObject<{
     channel?: string | undefined;
     preview?: string | undefined;
     agentId?: string | undefined;
-    sender?: string | undefined;
     confidence?: number | undefined;
+    sender?: string | undefined;
 }, {
     path: string[];
     status: "pending" | "approved" | "rejected";
@@ -6898,13 +7744,13 @@ declare const classificationSchema: z.ZodObject<{
     channel?: string | undefined;
     preview?: string | undefined;
     agentId?: string | undefined;
+    confidence?: number | undefined;
     sender?: string | undefined;
     proposedAxes?: Record<string, Record<string, string>> | undefined;
     leaf?: {
         output?: string | undefined;
         input?: string | undefined;
     } | undefined;
-    confidence?: number | undefined;
 }>;
 type Classification = z.infer<typeof classificationSchema>;
 /** Row in the fingerprint → path snap cache. */
@@ -7107,7 +7953,7 @@ declare class GraphStore {
      * Commit a full classification path: for each path element that doesn't
      * yet exist, infer its schema level by matching the proposed axes against
      * the level's required axes (first match ≥ cursor wins — this handles
-     * paths that skip levels, like business → noqta where location is
+     * paths that skip levels, like business → acme where location is
      * absent). Refreshes the node list between adds so callers in a loop
      * don't hit "Node id already exists" on the second iteration.
      */
@@ -7125,6 +7971,10 @@ declare class GraphStore {
      * state, not the original).
      */
     listPendingClassifications(limit?: number): Classification[];
+    /** Every classification, newest-first, collapsed one row per message.
+     *  The human-label queue needs the whole population rather than one
+     *  status, because the rows worth checking are the auto-approved ones. */
+    listAllClassifications(): Classification[];
     /** Same contract as listPendingClassifications but filtered to any status. */
     listByStatus(status: Classification["status"], limit?: number): Classification[];
     /**
@@ -7286,8 +8136,11 @@ declare class LandscapeBuilder {
 interface RunningTask {
     /** Unique id for this execution (timestamp-based). */
     id: string;
-    /** First 200 chars of the user message, for display. */
+    /** First 200 chars of the user message, for dense lists. */
     messagePreview: string;
+    /** The whole request. A task page shows what was actually asked, and the
+     *  preview cuts mid-sentence — or mid-JSON, which reads as a bug. */
+    message: string;
     /** Origin channel (telegram, whatsapp, gitlab, api, cron, business, a2a, …). */
     channel: string;
     /** Group / chat / issue id from which the task arrived. */
@@ -7330,6 +8183,11 @@ declare class AgentRegistry {
      *  prompt on every task. */
     readonly agentMemory: AgentMemory;
     private patternStore;
+    /** Model to drop mechanical tasks onto, from
+     *  `decisions.routing.cheapModel`. Unset means no routing happens at
+     *  all — the feature is off until an operator names the model, so it
+     *  cannot silently downgrade a fleet that never asked for it. */
+    private get cheapModel();
     private rateLimiter;
     private tokenTracker;
     private landscape?;
@@ -7415,9 +8273,9 @@ declare class AgentRegistry {
      * When `atMentionsOnly` is true, only `@`-prefixed mentions are considered.
      * This is used for messages originating from another bot (cross-daemon
      * Telegram cascades, for example) where we don't want bare-word matches
-     * like "nadia" in prose or "devops-mtgl" quoted in a reply to trigger
+     * like "marketing" in prose or "devops-globex" quoted in a reply to trigger
      * agents spuriously. Intentional handoffs still work because agents
-     * write explicit `@noqta_X_bot` handles.
+     * write explicit `@acme_X_bot` handles.
      */
     findByMention(text: string, opts?: {
         atMentionsOnly?: boolean;
@@ -7443,6 +8301,16 @@ declare class AgentRegistry {
      *
      *  Errors are swallowed by design — memory continuity is best-effort,
      *  it must never block or break the rotation it's hooked into. */
+    /**
+     * Ask the session-continuity seat whether to rotate before any
+     * mechanical trigger fires. Returns true only for a confident,
+     * active-mode early rotation.
+     *
+     * Never throws: askSeat is fail-open by contract, and everything else
+     * here is a guarded read. Off, shadow, backend error and missing
+     * history all return false, which is today's behaviour exactly.
+     */
+    private maybeRotateForContinuity;
     private captureRotationMemoAsync;
     /**
      * Build peer list for context engine.
@@ -7586,7 +8454,7 @@ declare class AgentRegistry {
         totalTokens: number;
         totalInput: number;
         totalOutput: number;
-        totalCacheRead: number;
+        totalCacheRead: number; /** Runtime handover store — shared with MessageRouter via file on disk. */
         totalCacheCreate: number;
         cacheHitRatio: number;
         totalErrors: number;
@@ -7946,7 +8814,7 @@ declare const businessConfigSchema: z.ZodObject<{
      *  existing agentx.json files validate without modification. */
     projects: z.ZodDefault<z.ZodArray<z.ZodObject<{
         /** Project identifier. For GitLab/GitHub: "owner/repo". For
-         *  noqta-internal projects: a stable string. */
+         *  acme-internal projects: a stable string. */
         id: z.ZodString;
         /** AgentId of the PM for this project. Looked up by
          *  `Organization.pmFor(project)` at dispatch time. */
@@ -8001,6 +8869,32 @@ declare const businessConfigSchema: z.ZodObject<{
         project?: string | undefined;
         displayName?: string | undefined;
     }>, "many">>;
+    /** Overrides for derived clients. Keyed by client id; absent entries get
+     *  defaults, so this stays empty until you need a clock or an
+     *  authorization. */
+    clients: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Display name. Defaults to the client id. */
+        name: z.ZodOptional<z.ZodString>;
+        /** "client" is someone who is waiting on you and can be let down; "own"
+         *  is your own product; "internal" is machinery with no external clock. */
+        kind: z.ZodOptional<z.ZodEnum<["client", "internal", "own"]>>;
+        /** How long a wait may last before it starts costing: "4h", "90m", "2d".
+         *  Unset means no external clock, so delay is flat. */
+        respondWithin: z.ZodOptional<z.ZodString>;
+        /** Capabilities an agent may exercise unattended. "*" means all. Ignored
+         *  for kind "client" — see mayProceedUnattended(). */
+        standing: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        standing: string[];
+        name?: string | undefined;
+        kind?: "client" | "internal" | "own" | undefined;
+        respondWithin?: string | undefined;
+    }, {
+        name?: string | undefined;
+        kind?: "client" | "internal" | "own" | undefined;
+        respondWithin?: string | undefined;
+        standing?: string[] | undefined;
+    }>>>;
     /** Work-tick cadence in minutes during business hours. Default 15. */
     workTickMinutes: z.ZodDefault<z.ZodNumber>;
     /** Max queue depth for an idle agent before skipping the work tick (avoids piling up). */
@@ -8089,6 +8983,12 @@ declare const businessConfigSchema: z.ZodObject<{
         project?: string | undefined;
         displayName?: string | undefined;
     }[];
+    clients: Record<string, {
+        standing: string[];
+        name?: string | undefined;
+        kind?: "client" | "internal" | "own" | undefined;
+        respondWithin?: string | undefined;
+    }>;
     workTickMinutes: number;
     idleQueueThreshold: number;
     standup: {
@@ -8150,6 +9050,12 @@ declare const businessConfigSchema: z.ZodObject<{
         project?: string | undefined;
         displayName?: string | undefined;
     }[] | undefined;
+    clients?: Record<string, {
+        name?: string | undefined;
+        kind?: "client" | "internal" | "own" | undefined;
+        respondWithin?: string | undefined;
+        standing?: string[] | undefined;
+    }> | undefined;
     workTickMinutes?: number | undefined;
     idleQueueThreshold?: number | undefined;
     standup?: {
@@ -8488,11 +9394,27 @@ declare class MessageRouter {
     private inflight;
     /** In-flight mesh forwards (this node is awaiting a peer's response).
      *  Counted so the daemon's shutdown drain can wait for these in addition
-     *  to local agent tasks — otherwise a clawd restart mid-forward kills the
+     *  to local agent tasks — otherwise a peer restart mid-forward kills the
      *  awaiter, the peer's response lands on a dead connection, and the
      *  inflight-replay re-runs the task on the peer. */
     private activeMeshForwards;
     getActiveMeshForwardCount(): number;
+    /** Messages addressed to an agent on a mesh peer that was unreachable at
+     *  the moment they arrived, keyed by peer name, replayed when the peer
+     *  comes back.
+     *
+     *  Before this existed a peer flap was silently destructive: the routing
+     *  pipeline saw an agent that no healthy peer advertised, called it
+     *  `unknown_agent`, and dropped the message for good. The mesh recovers on
+     *  its own within a probe cycle (~60s), but nothing replayed what was lost
+     *  in between, so the person who @-mentioned the agent just watched it
+     *  ignore them. Deliberately in-memory: a daemon restart drops the queue,
+     *  which is the safe direction — a stale replay is worse than a miss.
+     *  Bounded by both age and count so a peer that never returns cannot grow
+     *  it without limit. */
+    private deferredByPeer;
+    private readonly MESH_DEFER_TTL_MS;
+    private readonly MESH_DEFER_MAX_PER_PEER;
     constructor(registry: AgentRegistry, config: DaemonConfig, hooks?: HookRegistry, log?: (...args: unknown[]) => void);
     private loadDedupFromDisk;
     private scheduleDedupSave;
@@ -8599,6 +9521,28 @@ declare class MessageRouter {
     private attachUiExtras;
     private adapterEdit;
     private adapterReact;
+    /**
+     * Threads that have already been told about a mesh failure, keyed
+     * `${channel}:${chatId}`. Cleared on the next success for that thread, so a
+     * fresh outage notifies again but a burst inside one outage does not.
+     */
+    private meshFailureNotified;
+    /**
+     * A mesh-routed task failed. React ❌ (as the agent, where the channel
+     * supports identity) and — the FIRST time this thread fails — post one
+     * short comment saying so.
+     *
+     * Why a comment at all: this used to be ❌-only, on the reasoning that
+     * transient failures would pollute the thread. In practice a reporter who
+     * @-mentions a bot and gets 👀 then silence assumes the bot is ignoring
+     * them and keeps re-pinging — on acme/soylent#46 that was 9 mentions over
+     * 74 minutes of upstream 529s, every one of them silently dropped. One
+     * comment per outage is far cheaper than that. Nothing retries on its own,
+     * so the text says plainly that a re-mention is what resumes it.
+     */
+    private notifyMeshFailure;
+    /** A mesh-routed task succeeded — re-arm the failure notice for this thread. */
+    private clearMeshFailure;
     private startTypingLoop;
     private traceRoute;
     private runRoutingPipeline;
@@ -8621,6 +9565,27 @@ declare class MessageRouter {
      * Used when the channel adapter resolved the agent but it's not local.
      */
     private handleViaMeshByAgentId;
+    /**
+     * Hold a message addressed to an agent on an unreachable peer.
+     *
+     * Deduped by the same `<channel>:<accountId>:<id>` key the inbound dedupe
+     * uses, because the upstream that delivered the message often redelivers it
+     * while the peer is still down (GitLab retries its webhook), and we do not
+     * want the agent to answer the same mention twice on recovery.
+     */
+    private deferForPeer;
+    /**
+     * Replay everything held for a peer that just came back.
+     *
+     * Runs sequentially: each entry is a real agent turn on the remote node,
+     * and firing a backlog at it in parallel would spike a node that has only
+     * just recovered. Entries older than the TTL are dropped rather than
+     * answered — a reply to a 40-minute-old mention is noise.
+     */
+    private replayDeferred;
+    /** Held-message counts by peer — surfaced to the daemon for /health and
+     *  the dashboard so a growing backlog is visible rather than inferred. */
+    getDeferredMeshCounts(): Record<string, number>;
     /**
      * Route to a specific named mesh peer by agentId.
      * Used when preferNode is set on the incoming message.
@@ -8716,8 +9681,8 @@ declare class TelegramAdapter implements ChannelAdapter {
     private groupStore;
     /** Account IDs of bots currently active (member/administrator) in a group.
      *  Used by the router to pick the correct bot when an agent has multiple
-     *  Telegram accounts bound to it (e.g. pm-ksi → both @noqta_ksi_bot and
-     *  @noqta_pm_ksi_bot) — the in-group account should win, otherwise messages
+     *  Telegram accounts bound to it (e.g. pm-initech → both @acme_initech_bot and
+     *  @acme_pm_initech_bot) — the in-group account should win, otherwise messages
      *  to the absent bot get silently dropped by multi-account-dedup. */
     getGroupBotAccounts(groupId: string): string[];
     /**
@@ -9018,7 +9983,7 @@ declare class WhatsAppAdapter implements ChannelAdapter {
      *  Baileys' HistoryMessage shape to the channel-agnostic SeededMessage
      *  shape consumed by SessionStore on cold session create. Bounded by the
      *  caller's maxMessages/maxChars; fromMe → role:agent. The chatId is the
-     *  Baileys jid (e.g., "21694xxx@s.whatsapp.net" for DMs). */
+     *  Baileys jid (e.g., "1000000xxx@s.whatsapp.net" for DMs). */
     seedHistory(chatId: string, opts: {
         sinceISO?: string;
         maxMessages: number;
@@ -9037,6 +10002,9 @@ interface CronJobState {
     timezone: string;
     agent: string;
     prompt: string;
+    /** Run this shell command instead of dispatching the agent. See the
+     *  cron schema in daemon/config.ts for why this exists. */
+    command?: string;
     timeout: number;
     model?: string;
     /** Soft output-length cap appended to the prompt at invocation time.
@@ -9088,6 +10056,23 @@ declare class CronScheduler {
     setNotifyCallback(cb: CronNotifyCallback): void;
     start(): Promise<void>;
     stop(): Promise<void>;
+    /** Node stores a timer delay in a 32-bit signed int. Anything larger is
+     *  silently coerced to 1ms — the timer fires IMMEDIATELY and only a
+     *  TimeoutOverflowWarning on stderr says why. ~24.8 days. */
+    private static readonly MAX_TIMEOUT_MS;
+    /**
+     * Arm a timer for an absolute moment, however far away.
+     *
+     * A job scheduled further out than 24.8 days used to fire the instant
+     * the daemon started, every restart, forever. A monthly accounting job
+     * set for the 20th ran a month early on every deploy — and because the
+     * only symptom was a warning about integers, it read as noise.
+     *
+     * Long waits are split into hops. Each hop recomputes the remaining time
+     * from the TARGET rather than subtracting a constant, so the schedule
+     * cannot drift across sleeps, clock adjustments or a slow hop.
+     */
+    private armTimer;
     private scheduleNext;
     private scheduleRetry;
     /**
@@ -9097,6 +10082,20 @@ declare class CronScheduler {
      * until the 1c per-source promotion lands.
      */
     private recordCronDecisionInLedger;
+    /**
+     * Run a cron whose work is a shell command, with no model involved.
+     *
+     * Failure handling deliberately mirrors the agent path — same
+     * consecutiveErrors, same notify, same disable-after-three, same retry —
+     * so an operator does not have to learn two sets of cron semantics
+     * depending on how a job happens to be defined.
+     *
+     * Only the output TAIL is kept. The agent prompts this replaces all said
+     * "report the exit code plus the last 10 lines", which was the right
+     * instinct: a run record is read by a person after something broke, and
+     * the end of the output is where the breakage is.
+     */
+    private executeCommandJob;
     private executeJob;
     /**
      * Detect cron jobs that should have fired while the daemon was down.
@@ -9139,6 +10138,15 @@ interface ProviderCapabilities {
     vision: boolean;
     thinking: boolean;
     maxContext: number;
+    /** Can be made to return a value matching a schema, rather than prose the
+     *  caller has to parse. False does NOT mean "no structured output" — it
+     *  means no *guarantee*, so callers fall back to JSON-in-text plus a
+     *  correction round. The claude-code CLI on an OAuth credential is the
+     *  case that matters: ClaudeCodeProvider.generateRaw() throws there. */
+    structuredOutput: boolean;
+    /** Exposes per-token logprobs. The only source of a probability that is
+     *  the model's own posterior rather than a number it wrote out. */
+    logprobs: boolean;
 }
 declare const PROVIDER_CAPABILITIES: Record<string, ProviderCapabilities>;
 /**