@hotmeshio/long-tail 0.1.21 → 0.2.0

package/build/services/agent/sql.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESCALATION_COUNT = exports.KNOWLEDGE_COUNT = exports.SEED_AGENT = exports.DELETE_AGENT = exports.UPDATE_AGENT = exports.INSERT_AGENT = exports.GET_AGENT_BY_NAME = exports.GET_AGENT = exports.COUNT_AGENTS = exports.LIST_AGENTS = void 0;
+exports.LIST_AGENTS = `
+  SELECT a.*,
+    COALESCE(s.sub_count, 0)::int AS subscription_count,
+    s.sub_topics
+  FROM lt_agents a
+  LEFT JOIN LATERAL (
+    SELECT COUNT(*)::int AS sub_count,
+           array_agg(topic ORDER BY created_at) AS sub_topics
+    FROM lt_agent_subscriptions
+    WHERE agent_id = a.id AND enabled = true
+  ) s ON true
+  WHERE ($1::text IS NULL OR a.status = $1)
+    AND ($2::text IS NULL OR a.knowledge_domain = $2)
+  ORDER BY a.updated_at DESC
+  LIMIT $3 OFFSET $4
+`;
+exports.COUNT_AGENTS = `
+  SELECT COUNT(*)::int AS total FROM lt_agents
+  WHERE ($1::text IS NULL OR status = $1)
+    AND ($2::text IS NULL OR knowledge_domain = $2)
+`;
+exports.GET_AGENT = `
+  SELECT * FROM lt_agents WHERE id = $1
+`;
+exports.GET_AGENT_BY_NAME = `
+  SELECT * FROM lt_agents WHERE name = $1
+`;
+exports.INSERT_AGENT = `
+  INSERT INTO lt_agents (name, description, status, user_id, knowledge_domain,
+    capabilities, behaviors, goals, rules, workflow_type, pipeline_id, metadata)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+  RETURNING *
+`;
+exports.UPDATE_AGENT = `
+  UPDATE lt_agents SET
+    name = COALESCE($2, name),
+    description = COALESCE($3, description),
+    status = COALESCE($4, status),
+    user_id = COALESCE($5, user_id),
+    knowledge_domain = COALESCE($6, knowledge_domain),
+    capabilities = COALESCE($7, capabilities),
+    behaviors = COALESCE($8, behaviors),
+    goals = COALESCE($9, goals),
+    rules = COALESCE($10, rules),
+    workflow_type = COALESCE($11, workflow_type),
+    pipeline_id = COALESCE($12, pipeline_id),
+    metadata = COALESCE($13, metadata),
+    last_run_at = COALESCE($14, last_run_at)
+  WHERE id = $1
+  RETURNING *
+`;
+exports.DELETE_AGENT = `
+  DELETE FROM lt_agents WHERE id = $1
+`;
+exports.SEED_AGENT = `
+  INSERT INTO lt_agents (name, description, status, user_id, knowledge_domain,
+    capabilities, behaviors, goals, rules, workflow_type, pipeline_id, metadata)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+  ON CONFLICT (name) DO NOTHING
+`;
+exports.KNOWLEDGE_COUNT = `
+  SELECT COUNT(*)::int AS count FROM lt_knowledge WHERE domain = $1
+`;
+exports.ESCALATION_COUNT = `
+  SELECT COUNT(*)::int AS count FROM lt_escalations
+  WHERE status = 'pending' AND created_by = $1
+`;

package/build/services/agent/subscription-sql.d.ts

@@ -0,0 +1,7 @@
+export declare const LIST_SUBSCRIPTIONS = "\n  SELECT * FROM lt_agent_subscriptions\n  WHERE agent_id = $1\n  ORDER BY created_at\n";
+export declare const GET_SUBSCRIPTION = "\n  SELECT * FROM lt_agent_subscriptions WHERE id = $1\n";
+export declare const INSERT_SUBSCRIPTION = "\n  INSERT INTO lt_agent_subscriptions\n    (agent_id, topic, filter, reaction_type, workflow_type, pipeline_id, mcp_prompt,\n     input_mapping, execute_as, enabled)\n  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)\n  RETURNING *\n";
+export declare const UPDATE_SUBSCRIPTION = "\n  UPDATE lt_agent_subscriptions SET\n    topic = COALESCE($2, topic),\n    filter = COALESCE($3, filter),\n    reaction_type = COALESCE($4, reaction_type),\n    workflow_type = COALESCE($5, workflow_type),\n    pipeline_id = COALESCE($6, pipeline_id),\n    mcp_prompt = COALESCE($7, mcp_prompt),\n    input_mapping = COALESCE($8, input_mapping),\n    execute_as = COALESCE($9, execute_as),\n    enabled = COALESCE($10, enabled)\n  WHERE id = $1\n  RETURNING *\n";
+export declare const DELETE_SUBSCRIPTION = "\n  DELETE FROM lt_agent_subscriptions WHERE id = $1\n";
+export declare const SEED_SUBSCRIPTION = "\n  INSERT INTO lt_agent_subscriptions\n    (agent_id, topic, filter, reaction_type, workflow_type, pipeline_id, mcp_prompt,\n     input_mapping, execute_as, enabled)\n  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, true)\n  ON CONFLICT (agent_id, topic) DO NOTHING\n";
+export declare const LIST_ACTIVE_SUBSCRIPTIONS = "\n  SELECT s.*, a.name AS agent_name, a.user_id AS agent_user_id\n  FROM lt_agent_subscriptions s\n  JOIN lt_agents a ON s.agent_id = a.id\n  WHERE s.enabled = true AND a.status = 'active'\n  ORDER BY s.created_at\n";

package/build/services/agent/subscription-sql.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_ACTIVE_SUBSCRIPTIONS = exports.SEED_SUBSCRIPTION = exports.DELETE_SUBSCRIPTION = exports.UPDATE_SUBSCRIPTION = exports.INSERT_SUBSCRIPTION = exports.GET_SUBSCRIPTION = exports.LIST_SUBSCRIPTIONS = void 0;
+exports.LIST_SUBSCRIPTIONS = `
+  SELECT * FROM lt_agent_subscriptions
+  WHERE agent_id = $1
+  ORDER BY created_at
+`;
+exports.GET_SUBSCRIPTION = `
+  SELECT * FROM lt_agent_subscriptions WHERE id = $1
+`;
+exports.INSERT_SUBSCRIPTION = `
+  INSERT INTO lt_agent_subscriptions
+    (agent_id, topic, filter, reaction_type, workflow_type, pipeline_id, mcp_prompt,
+     input_mapping, execute_as, enabled)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+  RETURNING *
+`;
+exports.UPDATE_SUBSCRIPTION = `
+  UPDATE lt_agent_subscriptions SET
+    topic = COALESCE($2, topic),
+    filter = COALESCE($3, filter),
+    reaction_type = COALESCE($4, reaction_type),
+    workflow_type = COALESCE($5, workflow_type),
+    pipeline_id = COALESCE($6, pipeline_id),
+    mcp_prompt = COALESCE($7, mcp_prompt),
+    input_mapping = COALESCE($8, input_mapping),
+    execute_as = COALESCE($9, execute_as),
+    enabled = COALESCE($10, enabled)
+  WHERE id = $1
+  RETURNING *
+`;
+exports.DELETE_SUBSCRIPTION = `
+  DELETE FROM lt_agent_subscriptions WHERE id = $1
+`;
+exports.SEED_SUBSCRIPTION = `
+  INSERT INTO lt_agent_subscriptions
+    (agent_id, topic, filter, reaction_type, workflow_type, pipeline_id, mcp_prompt,
+     input_mapping, execute_as, enabled)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, true)
+  ON CONFLICT (agent_id, topic) DO NOTHING
+`;
+exports.LIST_ACTIVE_SUBSCRIPTIONS = `
+  SELECT s.*, a.name AS agent_name, a.user_id AS agent_user_id
+  FROM lt_agent_subscriptions s
+  JOIN lt_agents a ON s.agent_id = a.id
+  WHERE s.enabled = true AND a.status = 'active'
+  ORDER BY s.created_at
+`;

package/build/services/agent/subscriptions.d.ts

@@ -0,0 +1,30 @@
+export interface AgentSubscription {
+    id: string;
+    agent_id: string;
+    topic: string;
+    filter?: Record<string, any>;
+    reaction_type: 'durable' | 'pipeline' | 'mcp_query';
+    workflow_type?: string;
+    pipeline_id?: string;
+    mcp_prompt?: string;
+    input_mapping: Record<string, any>;
+    execute_as?: string;
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+}
+export interface ActiveSubscription extends AgentSubscription {
+    agent_name: string;
+    agent_user_id?: string;
+}
+export declare function listSubscriptions(agentId: string): Promise<AgentSubscription[]>;
+export declare function getSubscription(id: string): Promise<AgentSubscription | null>;
+export declare function createSubscription(agentId: string, data: Partial<AgentSubscription>): Promise<AgentSubscription>;
+export declare function updateSubscription(id: string, data: Partial<AgentSubscription>): Promise<AgentSubscription | null>;
+export declare function deleteSubscription(id: string): Promise<boolean>;
+export declare function listActiveSubscriptions(): Promise<ActiveSubscription[]>;
+/**
+ * Seed a subscription at startup (insert-if-absent).
+ * Conflict on (agent_id, topic) — DB is source of truth after first boot.
+ */
+export declare function seedSubscription(agentId: string, data: Partial<AgentSubscription>): Promise<boolean>;

package/build/services/agent/subscriptions.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSubscriptions = listSubscriptions;
+exports.getSubscription = getSubscription;
+exports.createSubscription = createSubscription;
+exports.updateSubscription = updateSubscription;
+exports.deleteSubscription = deleteSubscription;
+exports.listActiveSubscriptions = listActiveSubscriptions;
+exports.seedSubscription = seedSubscription;
+const db_1 = require("../../lib/db");
+const subscription_sql_1 = require("./subscription-sql");
+async function listSubscriptions(agentId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(subscription_sql_1.LIST_SUBSCRIPTIONS, [agentId]);
+    return rows;
+}
+async function getSubscription(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(subscription_sql_1.GET_SUBSCRIPTION, [id]);
+    return rows[0] ?? null;
+}
+async function createSubscription(agentId, data) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(subscription_sql_1.INSERT_SUBSCRIPTION, [
+        agentId,
+        data.topic,
+        data.filter ? JSON.stringify(data.filter) : null,
+        data.reaction_type,
+        data.workflow_type ?? null,
+        data.pipeline_id ?? null,
+        data.mcp_prompt ?? null,
+        JSON.stringify(data.input_mapping ?? {}),
+        data.execute_as ?? null,
+        data.enabled !== false,
+    ]);
+    return rows[0];
+}
+async function updateSubscription(id, data) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(subscription_sql_1.UPDATE_SUBSCRIPTION, [
+        id,
+        data.topic ?? null,
+        data.filter ? JSON.stringify(data.filter) : null,
+        data.reaction_type ?? null,
+        data.workflow_type ?? null,
+        data.pipeline_id ?? null,
+        data.mcp_prompt ?? null,
+        data.input_mapping ? JSON.stringify(data.input_mapping) : null,
+        data.execute_as ?? null,
+        data.enabled ?? null,
+    ]);
+    return rows[0] ?? null;
+}
+async function deleteSubscription(id) {
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(subscription_sql_1.DELETE_SUBSCRIPTION, [id]);
+    return (rowCount ?? 0) > 0;
+}
+async function listActiveSubscriptions() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(subscription_sql_1.LIST_ACTIVE_SUBSCRIPTIONS);
+    return rows;
+}
+/**
+ * Seed a subscription at startup (insert-if-absent).
+ * Conflict on (agent_id, topic) — DB is source of truth after first boot.
+ */
+async function seedSubscription(agentId, data) {
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(subscription_sql_1.SEED_SUBSCRIPTION, [
+        agentId,
+        data.topic,
+        data.filter ? JSON.stringify(data.filter) : null,
+        data.reaction_type,
+        data.workflow_type ?? null,
+        data.pipeline_id ?? null,
+        data.mcp_prompt ?? null,
+        JSON.stringify(data.input_mapping ?? {}),
+        data.execute_as ?? null,
+    ]);
+    return (rowCount ?? 0) > 0;
+}

package/build/services/agent/trigger-registry.d.ts

@@ -0,0 +1,45 @@
+import type { CallbackEventAdapter } from '../../lib/events/callback';
+/**
+ * Agent Trigger Registry — arms event subscriptions for active agents at startup.
+ *
+ * Analogous to LTCronRegistry but for event-driven reactions. When an event
+ * matches a subscription's topic pattern (and optional filter), the registry
+ * invokes the configured workflow with a deterministic ID for distributed dedup.
+ */
+declare class AgentTriggerRegistry {
+    private adapter;
+    private unsubs;
+    private connected;
+    /**
+     * Load all active subscriptions from DB and arm event listeners.
+     */
+    connect(adapter: CallbackEventAdapter): Promise<void>;
+    /**
+     * Re-arm all subscriptions for a specific agent (after config change).
+     */
+    restartAgent(agentId: string): Promise<void>;
+    /**
+     * Stop all subscriptions for a specific agent.
+     */
+    stopAgent(agentId: string): void;
+    /**
+     * Disconnect all subscriptions.
+     */
+    disconnect(): void;
+    private armSubscription;
+    private buildHandler;
+    /**
+     * Shallow key-value match: every key in filter must match the corresponding
+     * key in event.data. Missing keys in event.data fail the match.
+     */
+    private matchesFilter;
+    /**
+     * Deterministic workflow ID derived from the subscription + event.
+     * Multiple containers receiving the same event produce the same ID,
+     * so HotMesh's idempotent workflow.start() prevents duplicate execution.
+     */
+    private deriveWorkflowId;
+    private executeReaction;
+}
+export declare const agentTriggerRegistry: AgentTriggerRegistry;
+export {};

package/build/services/agent/trigger-registry.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentTriggerRegistry = void 0;
+const crypto_1 = require("crypto");
+const logger_1 = require("../../lib/logger");
+const publish_1 = require("../../lib/events/publish");
+const subscriptions_1 = require("./subscriptions");
+const input_mapper_1 = require("./input-mapper");
+const index_1 = require("./index");
+/**
+ * Agent Trigger Registry — arms event subscriptions for active agents at startup.
+ *
+ * Analogous to LTCronRegistry but for event-driven reactions. When an event
+ * matches a subscription's topic pattern (and optional filter), the registry
+ * invokes the configured workflow with a deterministic ID for distributed dedup.
+ */
+class AgentTriggerRegistry {
+    constructor() {
+        this.adapter = null;
+        this.unsubs = new Map();
+        this.connected = false;
+    }
+    /**
+     * Load all active subscriptions from DB and arm event listeners.
+     */
+    async connect(adapter) {
+        this.adapter = adapter;
+        const subs = await (0, subscriptions_1.listActiveSubscriptions)();
+        for (const sub of subs) {
+            this.armSubscription(sub);
+        }
+        this.connected = true;
+        logger_1.loggerRegistry.info(`[long-tail] agent trigger registry: ${subs.length} subscription(s) armed`);
+    }
+    /**
+     * Re-arm all subscriptions for a specific agent (after config change).
+     */
+    async restartAgent(agentId) {
+        if (!this.adapter)
+            return;
+        // Stop existing subs for this agent
+        for (const [key, unsub] of this.unsubs) {
+            if (key.startsWith(`${agentId}:`)) {
+                unsub();
+                this.unsubs.delete(key);
+            }
+        }
+        // Reload from DB
+        const subs = await (0, subscriptions_1.listActiveSubscriptions)();
+        const agentSubs = subs.filter((s) => s.agent_id === agentId);
+        for (const sub of agentSubs) {
+            this.armSubscription(sub);
+        }
+        logger_1.loggerRegistry.info(`[long-tail] agent triggers restarted for ${agentId}: ${agentSubs.length} sub(s)`);
+    }
+    /**
+     * Stop all subscriptions for a specific agent.
+     */
+    stopAgent(agentId) {
+        for (const [key, unsub] of this.unsubs) {
+            if (key.startsWith(`${agentId}:`)) {
+                unsub();
+                this.unsubs.delete(key);
+            }
+        }
+    }
+    /**
+     * Disconnect all subscriptions.
+     */
+    disconnect() {
+        for (const unsub of this.unsubs.values()) {
+            unsub();
+        }
+        this.unsubs.clear();
+        this.connected = false;
+        logger_1.loggerRegistry.info('[long-tail] agent trigger registry disconnected');
+    }
+    armSubscription(sub) {
+        if (!this.adapter)
+            return;
+        const key = `${sub.agent_id}:${sub.id}`;
+        const handler = this.buildHandler(sub);
+        // Normalize topic: strip the 'lt.events.' prefix if present, since
+        // CallbackEventAdapter matches against raw event.type (e.g., 'workflow.failed',
+        // not 'lt.events.workflow.failed'). Users may store either form in the DB.
+        const rawTopic = sub.topic.replace(/^lt\.events\./, '');
+        const unsub = this.adapter.on(rawTopic, handler);
+        this.unsubs.set(key, unsub);
+    }
+    buildHandler(sub) {
+        return async (event) => {
+            try {
+                // 1. Evaluate optional filter
+                if (sub.filter && !this.matchesFilter(event, sub.filter)) {
+                    return;
+                }
+                // 2. Derive deterministic workflow ID for distributed dedup
+                const deterministicId = this.deriveWorkflowId(sub, event);
+                // 3. Apply input mapping to transform event → envelope data
+                const mapped = Object.keys(sub.input_mapping).length > 0
+                    ? (0, input_mapper_1.applyInputMapping)(sub.input_mapping, event)
+                    : { data: event.data ?? {}, metadata: { source: 'agent', agentName: sub.agent_name } };
+                // 4. Emit agent.started
+                (0, publish_1.publishAgentEvent)({
+                    type: 'agent.started',
+                    agentId: sub.agent_id,
+                    agentName: sub.agent_name,
+                    data: { topic: sub.topic, eventType: event.type, deterministicId },
+                });
+                // 5. Invoke the reaction workflow
+                await this.executeReaction(sub, mapped, deterministicId);
+                // 6. Emit agent.completed + update last_run_at
+                (0, publish_1.publishAgentEvent)({
+                    type: 'agent.completed',
+                    agentId: sub.agent_id,
+                    agentName: sub.agent_name,
+                    data: { topic: sub.topic, eventType: event.type },
+                });
+                (0, index_1.updateAgent)(sub.agent_id, {
+                    last_run_at: new Date().toISOString(),
+                }).catch(() => { }); // best-effort
+            }
+            catch (err) {
+                (0, publish_1.publishAgentEvent)({
+                    type: 'agent.failed',
+                    agentId: sub.agent_id,
+                    agentName: sub.agent_name,
+                    status: 'error',
+                    data: { topic: sub.topic, error: err.message },
+                });
+                logger_1.loggerRegistry.warn(`[long-tail] agent trigger failed: ${sub.agent_name}/${sub.topic}: ${err.message}`);
+            }
+        };
+    }
+    /**
+     * Shallow key-value match: every key in filter must match the corresponding
+     * key in event.data. Missing keys in event.data fail the match.
+     */
+    matchesFilter(event, filter) {
+        const data = event.data ?? {};
+        for (const [key, expected] of Object.entries(filter)) {
+            if (data[key] !== expected)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Deterministic workflow ID derived from the subscription + event.
+     * Multiple containers receiving the same event produce the same ID,
+     * so HotMesh's idempotent workflow.start() prevents duplicate execution.
+     */
+    deriveWorkflowId(sub, event) {
+        const eventKey = event.workflowId || event.taskId || event.escalationId || '';
+        const uniquePart = eventKey || (0, crypto_1.createHash)('sha256')
+            .update(`${event.timestamp}:${event.type}:${JSON.stringify(event.data ?? {})}`)
+            .digest('hex')
+            .slice(0, 12);
+        return `agent-${sub.agent_id.slice(0, 8)}-${sub.id.slice(0, 8)}-${uniquePart}`;
+    }
+    async executeReaction(sub, mapped, deterministicId) {
+        switch (sub.reaction_type) {
+            case 'durable': {
+                const { invokeWorkflow } = await Promise.resolve().then(() => __importStar(require('../workflow-invocation')));
+                await invokeWorkflow({
+                    workflowType: sub.workflow_type,
+                    data: mapped.data ?? mapped,
+                    metadata: mapped.metadata ?? { source: 'agent', certified: true },
+                    executeAs: sub.execute_as ?? sub.agent_user_id ?? undefined,
+                    options: { workflowId: deterministicId },
+                    auth: { userId: sub.agent_user_id || 'lt-system', role: 'admin' },
+                });
+                break;
+            }
+            case 'pipeline': {
+                const { invokeYamlWorkflow } = await Promise.resolve().then(() => __importStar(require('../yaml-workflow/invoke')));
+                const { getYamlWorkflow } = await Promise.resolve().then(() => __importStar(require('../yaml-workflow/db')));
+                const wf = await getYamlWorkflow(sub.pipeline_id);
+                if (!wf)
+                    throw new Error(`Pipeline ${sub.pipeline_id} not found`);
+                await invokeYamlWorkflow(wf, {
+                    data: mapped.data ?? mapped,
+                    execute_as: sub.execute_as ?? sub.agent_user_id ?? undefined,
+                    source: 'agent',
+                });
+                break;
+            }
+            case 'mcp_query': {
+                const { startMcpQuery } = await Promise.resolve().then(() => __importStar(require('../insight')));
+                await startMcpQuery({
+                    prompt: sub.mcp_prompt,
+                    wait: false,
+                    userId: sub.agent_user_id ?? undefined,
+                });
+                break;
+            }
+        }
+    }
+}
+exports.agentTriggerRegistry = new AgentTriggerRegistry();

package/build/services/cron/index.d.ts

@@ -1,4 +1,4 @@
-import type { LTWorkflowConfig } from '../../types';
+import type { LTWorkflowConfig, LTAgent, AgentSchedule } from '../../types';
 import type { LTYamlWorkflowRecord } from '../../types/yaml-workflow';
 /**
  * Validate a cron expression and enforce a minimum interval.
@@ -52,6 +52,22 @@ declare class LTCronRegistry {
      * Restart a YAML workflow cron after config change.
      */
     restartYamlCron(wf: LTYamlWorkflowRecord): Promise<void>;
+    /**
+     * Start a single agent schedule cron.
+     */
+    startAgentCron(agent: LTAgent, schedule: AgentSchedule, idx: number): Promise<void>;
+    /**
+     * Stop all cron schedules for an agent.
+     */
+    stopAgentCrons(agentId: string): Promise<void>;
+    /**
+     * Restart all cron schedules for an agent (after config change or pause/resume).
+     */
+    restartAgentCrons(agent: LTAgent): Promise<void>;
+    /**
+     * Arm all cron schedules for active agents. Called at startup.
+     */
+    connectAgentCrons(): Promise<void>;
     /**
      * Stop all active crons. Call during graceful shutdown.
      */