@gonzih/cc-discord 0.2.26 → 0.2.27

package/dist/bot.d.ts

@@ -36,7 +36,6 @@ export declare class CcDiscordBot {
     private lastActiveChannelId?;
     private cron;
     private cronEngine?;
-    private loopEngine?;
     private metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     private mcpSession?;
@@ -101,12 +100,6 @@ export declare class CcDiscordBot {
      * Namespace is derived from the channel's registered namespace (same pattern as /clear and /compact).
      */
     private handleCronEngineCommand;
-    /**
-     * Handle the /loop command group — backed by LoopEngine (Redis-persisted, interval-based).
-     * Loops fire immediately on creation and on startup, then repeat every intervalMs ms.
-     * Namespace is derived from the channel's registered namespace.
-     */
-    private handleLoopEngineCommand;
     /**
      * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
      * Returns the tool result as a string, or null on failure.
@@ -157,12 +150,6 @@ export declare class CcDiscordBot {
      * Called from index.ts after startup migrations complete (alongside startMetaAgentPolling).
      */
     startCronEngine(): void;
-    /**
-     * Start the LoopEngine — loads all active loops from Redis, fires each immediately,
-     * then starts their repeat timers.
-     * Called from index.ts after startup migrations complete (alongside startCronEngine).
-     */
-    startLoopEngine(): void;
     /**
      * Resolve the namespace for a given channelId.
      * Routed channels use their registered namespace; everything else uses the bot's primary namespace.

package/dist/bot.js

@@ -16,7 +16,6 @@ import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
 import { CronManager } from "./cron.js";
 import { CronEngine, cronPendingKey, CRON_MESSAGE_TTL } from "./cron-engine.js";
-import { LoopEngine, parseIntervalMs } from "./loop-engine.js";
 import { parseChannelCreateIntent, routeToMetaAgent } from "./router.js";
 import { createMetaAgentManager } from "./meta-agent-manager.js";
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
@@ -123,7 +122,6 @@ export class CcDiscordBot {
     lastActiveChannelId;
     cron;
     cronEngine;
-    loopEngine;
     metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     mcpSession;
@@ -134,7 +132,6 @@ export class CcDiscordBot {
         if (opts.redis) {
             this.wire = createCcWire(opts.redis);
             this.cronEngine = new CronEngine(opts.redis);
-            this.loopEngine = new LoopEngine(opts.redis);
         }
         this.metaAgentManager = createMetaAgentManager();
         this.client = new Client({
@@ -845,28 +842,6 @@ export class CcDiscordBot {
                 .setName("delete")
                 .setDescription("Delete a cron job permanently")
                 .addStringOption((opt) => opt.setName("id").setDescription("Cron ID").setRequired(true))),
-            new SlashCommandBuilder()
-                .setName("loop")
-                .setDescription("Manage Redis-persisted interval loops for this channel's namespace")
-                .addSubcommand((sub) => sub
-                .setName("add")
-                .setDescription("Add a loop (fires immediately, then repeats at fixed interval)")
-                .addStringOption((opt) => opt.setName("interval").setDescription("Interval e.g. '30m', '1h', '20m', '30s'").setRequired(true))
-                .addStringOption((opt) => opt.setName("message").setDescription("Message to push to the meta-agent input queue").setRequired(true))
-                .addIntegerOption((opt) => opt.setName("compact_every").setDescription("Push /compact every N fires (default: 10, 0 = never)").setRequired(false)))
-                .addSubcommand((sub) => sub.setName("list").setDescription("List all loops for this namespace"))
-                .addSubcommand((sub) => sub
-                .setName("pause")
-                .setDescription("Pause a loop")
-                .addStringOption((opt) => opt.setName("id").setDescription("Loop ID").setRequired(true)))
-                .addSubcommand((sub) => sub
-                .setName("resume")
-                .setDescription("Resume a paused loop (fires immediately)")
-                .addStringOption((opt) => opt.setName("id").setDescription("Loop ID").setRequired(true)))
-                .addSubcommand((sub) => sub
-                .setName("delete")
-                .setDescription("Delete a loop permanently")
-                .addStringOption((opt) => opt.setName("id").setDescription("Loop ID").setRequired(true))),
         ].map((cmd) => cmd.toJSON());
         const rest = new REST().setToken(this.opts.discordToken);
         if (this.opts.guildIds?.length) {
@@ -1017,10 +992,6 @@ export class CcDiscordBot {
                 await this.handleCronEngineCommand(interaction, channelId);
                 break;
             }
-            case "loop": {
-                await this.handleLoopEngineCommand(interaction, channelId);
-                break;
-            }
         }
     }
     async handleCronsCommand(interaction, channelId) {
@@ -1142,82 +1113,6 @@ export class CcDiscordBot {
                 await interaction.reply("Unknown /cron subcommand.");
         }
     }
-    /**
-     * Handle the /loop command group — backed by LoopEngine (Redis-persisted, interval-based).
-     * Loops fire immediately on creation and on startup, then repeat every intervalMs ms.
-     * Namespace is derived from the channel's registered namespace.
-     */
-    async handleLoopEngineCommand(interaction, channelId) {
-        if (!this.loopEngine) {
-            await interaction.reply({ content: "Loop engine unavailable (no Redis connection).", ephemeral: true });
-            return;
-        }
-        const ns = this.resolveNamespaceForChannel(channelId);
-        const sub = interaction.options.getSubcommand();
-        switch (sub) {
-            case "add": {
-                const intervalStr = interaction.options.getString("interval", true);
-                const message = interaction.options.getString("message", true);
-                const compactEvery = interaction.options.getInteger("compact_every") ?? 10;
-                const intervalMs = parseIntervalMs(intervalStr);
-                if (intervalMs === null || intervalMs <= 0) {
-                    await interaction.reply(`Invalid interval: \`${intervalStr}\`\nUse format: \`30s\`, \`5m\`, \`20m\`, \`1h\`, \`2h\`, \`1d\``);
-                    return;
-                }
-                await interaction.deferReply();
-                const rec = await this.loopEngine.add(ns, intervalMs, message, compactEvery);
-                const humanInterval = intervalStr;
-                await interaction.editReply(`Loop added for namespace **${ns}**\nID: \`${rec.id}\`\nInterval: \`${humanInterval}\` (${intervalMs}ms)\nCompact every: ${rec.compactEvery} fires\n(Fired immediately on creation.)`);
-                break;
-            }
-            case "list": {
-                await interaction.deferReply();
-                const allLoops = await this.loopEngine.list();
-                const nsLoops = allLoops.filter((r) => r.namespace === ns);
-                if (nsLoops.length === 0) {
-                    await interaction.editReply(`No loops for namespace **${ns}**.`);
-                }
-                else {
-                    const embed = new EmbedBuilder()
-                        .setTitle(`Loops — ${ns}`)
-                        .setColor(0x57F287)
-                        .setDescription(nsLoops
-                        .map((r) => {
-                        const statusEmoji = r.status === "active" ? "🟢" : "⏸️";
-                        const last = r.lastRun ? `last run ${r.lastRun}` : "never run";
-                        const intervalSec = Math.round(r.intervalMs / 1000);
-                        return `${statusEmoji} **\`${r.id}\`** [${r.status}]\nInterval: ${intervalSec}s | Fires: ${r.fireCount} | ${last}\nMessage: \`${r.message.slice(0, 80)}${r.message.length > 80 ? "…" : ""}\``;
-                    })
-                        .join("\n\n"));
-                    await interaction.editReply({ embeds: [embed] });
-                }
-                break;
-            }
-            case "pause": {
-                const id = interaction.options.getString("id", true);
-                await interaction.deferReply();
-                const ok = await this.loopEngine.pause(id);
-                await interaction.editReply(ok ? `Loop \`${id}\` paused.` : `Loop \`${id}\` not found.`);
-                break;
-            }
-            case "resume": {
-                const id = interaction.options.getString("id", true);
-                await interaction.deferReply();
-                const ok = await this.loopEngine.resume(id);
-                await interaction.editReply(ok ? `Loop \`${id}\` resumed (fired immediately).` : `Loop \`${id}\` not found.`);
-                break;
-            }
-            case "delete": {
-                const id = interaction.options.getString("id", true);
-                await interaction.deferReply();
-                const ok = await this.loopEngine.delete(id);
-                await interaction.editReply(ok ? `Loop \`${id}\` deleted.` : `Loop \`${id}\` not found.`);
-                break;
-            }
-            default:
-                await interaction.reply("Unknown /loop subcommand.");
-        }
-    }
     /**
      * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
      * Returns the tool result as a string, or null on failure.
@@ -1461,18 +1356,6 @@ export class CcDiscordBot {
             console.warn("[bot] cronEngine.start() failed:", err.message);
         });
     }
-    /**
-     * Start the LoopEngine — loads all active loops from Redis, fires each immediately,
-     * then starts their repeat timers.
-     * Called from index.ts after startup migrations complete (alongside startCronEngine).
-     */
-    startLoopEngine() {
-        if (!this.loopEngine)
-            return;
-        this.loopEngine.start().catch((err) => {
-            console.warn("[bot] loopEngine.start() failed:", err.message);
-        });
-    }
     /**
      * Resolve the namespace for a given channelId.
      * Routed channels use their registered namespace; everything else uses the bot's primary namespace.
@@ -1569,7 +1452,6 @@ export class CcDiscordBot {
             this.stopMetaAgentTyping(channelId);
         }
         this.metaAgentManager.stop();
-        this.loopEngine?.stop();
         void this.client.destroy();
     }
 }

package/dist/index.js

@@ -145,8 +145,6 @@ async function runStartupMigrations() {
     bot.startMetaAgentPolling();
     // 4. Start cron engine — loads and schedules all Redis-persisted crons
     bot.startCronEngine();
-    // 5. Start loop engine — loads all active loops, fires each immediately, then starts timers
-    bot.startLoopEngine();
 }
 // Mutable placeholder closures — filled in once `bot` is created below
 let getLastActiveChannelIdFn = () => undefined;

package/dist/notifier.js

@@ -112,14 +112,17 @@ export function parseNotification(raw) {
     let isCron = false;
     try {
         const parsed = JSON.parse(raw);
+        // Accept 'targets' as alias for 'routing' (coordinator sessions use this format)
+        const routingArr = parsed.routing ?? parsed.targets;
         // routing: absent/empty → all transports; non-empty → only listed transports
-        if (parsed.routing && parsed.routing.length > 0 && !parsed.routing.includes("discord")) {
+        if (routingArr && routingArr.length > 0 && !routingArr.includes("discord")) {
             return null;
         }
         if (parsed.is_cron === true)
             return null;
-        if (parsed.text)
-            text = parsed.text;
+        // Accept 'message' as alias for 'text'
+        if (parsed.text ?? parsed.message)
+            text = (parsed.text ?? parsed.message);
         driver = parsed.driver;
         model = parsed.model;
         if (typeof parsed.cost === "number")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "dist/"
   ],
   "dependencies": {
-    "@gonzih/cc-wire": "^0.4.1",
+    "@gonzih/cc-wire": "^0.4.0",
     "@types/node-cron": "^3.0.11",
     "discord.js": "^14.0.0",
     "ioredis": "^5.0.0",

package/dist/loop-engine.d.ts

@@ -1,110 +0,0 @@
-/**
- * LoopEngine — Redis-persisted, interval-based meta-agent messaging.
- *
- * Loops differ from crons:
- *   - Fire IMMEDIATELY on creation and on startup
- *   - Repeat at a fixed millisecond interval (not a cron expression)
- *
- * Redis key schema:
- *   cca:discord:loop:list          — SET of loop IDs
- *   cca:discord:loop:{id}          — HASH with fields:
- *                                      id, namespace, message, interval_ms,
- *                                      fire_count, compact_every, status,
- *                                      last_run, created_at
- *
- * On each fire:
- *   1. Increment fire_count
- *   2. Duplicate check: LRANGE cca:discord:meta:{ns}:input 0 -1
- *      — skip if the exact message is already queued
- *   3. If fire_count % compact_every === 0: RPUSH /compact first
- *   4. RPUSH JSON entry to cca:discord:meta:{ns}:input
- *   5. Update last_run
- */
-import type { Redis } from "ioredis";
-/**
- * Temporary key written by the loop engine when it fires a loop.
- * Value is the loopId that fired. TTL 300s.
- * The bot reads this after sending a Discord message to link the message to the loop.
- */
-export declare const loopPendingKey: (ns: string) => string;
-/**
- * Key that maps a sent Discord messageId → loopId.
- * Used by the reaction handler to look up which loop to disable.
- * TTL 86400s (24h).
- */
-export declare const LOOP_MESSAGE_TTL = 86400;
-/**
- * Parse a human-readable interval string to milliseconds.
- * Supports: 30s, 5m, 20m, 1h, 2h, 1d, 7d, etc.
- * Returns null if the format is unrecognised.
- */
-export declare function parseIntervalMs(input: string): number | null;
-export interface LoopRecord {
-    id: string;
-    namespace: string;
-    message: string;
-    intervalMs: number;
-    fireCount: number;
-    compactEvery: number;
-    status: "active" | "paused";
-    lastRun: string;
-    createdAt: string;
-}
-export declare class LoopEngine {
-    private redis;
-    /** Map of loop ID → NodeJS.Timeout handle */
-    private timers;
-    constructor(redis: Redis);
-    /**
-     * Add a new loop.
-     * Fires immediately, then repeats every intervalMs milliseconds.
-     *
-     * @param namespace   The meta-agent namespace to push messages to.
-     * @param intervalMs  Milliseconds between fires.
-     * @param message     Text content to push into the meta-agent input queue.
-     * @param compactEvery  Push /compact every N fires. Defaults to 10. 0 = never.
-     * @returns The created LoopRecord.
-     */
-    add(namespace: string, intervalMs: number, message: string, compactEvery?: number): Promise<LoopRecord>;
-    /**
-     * List all loops stored in Redis.
-     */
-    list(): Promise<LoopRecord[]>;
-    /**
-     * Pause a loop (sets status=paused and clears the timer).
-     */
-    pause(id: string): Promise<boolean>;
-    /**
-     * Resume a paused loop (sets status=active, fires immediately, then restarts timer).
-     */
-    resume(id: string): Promise<boolean>;
-    /**
-     * Delete a loop (clears timer and removes from Redis).
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Load all active loops from Redis, fire each immediately, then start their timers.
-     * Call once after the bot connects and Redis is ready.
-     */
-    start(): Promise<void>;
-    /**
-     * Stop all running timers. Does not modify Redis.
-     */
-    stop(): void;
-    private startTimer;
-    private clearTimer;
-    /**
-     * Execute one loop tick:
-     *  1. Reload record (picks up any pause between schedule and fire)
-     *  2. Increment fireCount
-     *  3. Duplicate check against the input queue
-     *  4. Optionally push /compact
-     *  5. Push the message
-     *  6. Update lastRun
-     */
-    fire(id: string): Promise<void>;
-    /** Write a LoopRecord to Redis as a HASH. */
-    private saveRecord;
-    /** Load a LoopRecord from Redis. Returns null if the key doesn't exist. */
-    private loadRecord;
-}

package/dist/loop-engine.js

@@ -1,312 +0,0 @@
-/**
- * LoopEngine — Redis-persisted, interval-based meta-agent messaging.
- *
- * Loops differ from crons:
- *   - Fire IMMEDIATELY on creation and on startup
- *   - Repeat at a fixed millisecond interval (not a cron expression)
- *
- * Redis key schema:
- *   cca:discord:loop:list          — SET of loop IDs
- *   cca:discord:loop:{id}          — HASH with fields:
- *                                      id, namespace, message, interval_ms,
- *                                      fire_count, compact_every, status,
- *                                      last_run, created_at
- *
- * On each fire:
- *   1. Increment fire_count
- *   2. Duplicate check: LRANGE cca:discord:meta:{ns}:input 0 -1
- *      — skip if the exact message is already queued
- *   3. If fire_count % compact_every === 0: RPUSH /compact first
- *   4. RPUSH JSON entry to cca:discord:meta:{ns}:input
- *   5. Update last_run
- */
-import { randomUUID } from "crypto";
-import { loopListKey, loopHashKey, discordMetaInputKey as metaInputKey, } from "@gonzih/cc-wire";
-// ─── Redis key helpers ────────────────────────────────────────────────────────
-const LOOP_LIST_KEY = loopListKey();
-/**
- * Temporary key written by the loop engine when it fires a loop.
- * Value is the loopId that fired. TTL 300s.
- * The bot reads this after sending a Discord message to link the message to the loop.
- */
-export const loopPendingKey = (ns) => `cca:discord:loop-pending:${ns}`;
-/**
- * Key that maps a sent Discord messageId → loopId.
- * Used by the reaction handler to look up which loop to disable.
- * TTL 86400s (24h).
- */
-export const LOOP_MESSAGE_TTL = 86400;
-// ─── Human-readable interval parsing ─────────────────────────────────────────
-/**
- * Parse a human-readable interval string to milliseconds.
- * Supports: 30s, 5m, 20m, 1h, 2h, 1d, 7d, etc.
- * Returns null if the format is unrecognised.
- */
-export function parseIntervalMs(input) {
-    const trimmed = input.trim().toLowerCase();
-    const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/);
-    if (!match)
-        return null;
-    const value = parseFloat(match[1]);
-    const unit = match[2];
-    if (value <= 0 || !isFinite(value))
-        return null;
-    switch (unit) {
-        case "ms": return Math.round(value);
-        case "s": return Math.round(value * 1_000);
-        case "m": return Math.round(value * 60_000);
-        case "h": return Math.round(value * 3_600_000);
-        case "d": return Math.round(value * 86_400_000);
-        default: return null;
-    }
-}
-// ─── LoopEngine ───────────────────────────────────────────────────────────────
-export class LoopEngine {
-    redis;
-    /** Map of loop ID → NodeJS.Timeout handle */
-    timers = new Map();
-    constructor(redis) {
-        this.redis = redis;
-    }
-    /**
-     * Add a new loop.
-     * Fires immediately, then repeats every intervalMs milliseconds.
-     *
-     * @param namespace   The meta-agent namespace to push messages to.
-     * @param intervalMs  Milliseconds between fires.
-     * @param message     Text content to push into the meta-agent input queue.
-     * @param compactEvery  Push /compact every N fires. Defaults to 10. 0 = never.
-     * @returns The created LoopRecord.
-     */
-    async add(namespace, intervalMs, message, compactEvery = 10) {
-        const id = randomUUID();
-        const now = new Date().toISOString();
-        const record = {
-            id,
-            namespace,
-            message,
-            intervalMs,
-            fireCount: 0,
-            compactEvery,
-            status: "active",
-            lastRun: "",
-            createdAt: now,
-        };
-        await this.saveRecord(record);
-        await this.redis.sadd(LOOP_LIST_KEY, id);
-        // Fire immediately, then schedule repeating interval
-        await this.fire(id);
-        this.startTimer(record);
-        console.log(`[loop-engine] added loop id=${id} ns=${namespace} intervalMs=${intervalMs}`);
-        return record;
-    }
-    /**
-     * List all loops stored in Redis.
-     */
-    async list() {
-        const ids = await this.redis.smembers(LOOP_LIST_KEY);
-        const records = [];
-        for (const id of ids) {
-            const rec = await this.loadRecord(id);
-            if (rec)
-                records.push(rec);
-        }
-        return records;
-    }
-    /**
-     * Pause a loop (sets status=paused and clears the timer).
-     */
-    async pause(id) {
-        const rec = await this.loadRecord(id);
-        if (!rec)
-            return false;
-        rec.status = "paused";
-        await this.saveRecord(rec);
-        this.clearTimer(id);
-        console.log(`[loop-engine] paused loop id=${id}`);
-        return true;
-    }
-    /**
-     * Resume a paused loop (sets status=active, fires immediately, then restarts timer).
-     */
-    async resume(id) {
-        const rec = await this.loadRecord(id);
-        if (!rec)
-            return false;
-        rec.status = "active";
-        await this.saveRecord(rec);
-        // Fire immediately then start interval
-        await this.fire(id);
-        this.startTimer(rec);
-        console.log(`[loop-engine] resumed loop id=${id}`);
-        return true;
-    }
-    /**
-     * Delete a loop (clears timer and removes from Redis).
-     */
-    async delete(id) {
-        const rec = await this.loadRecord(id);
-        if (!rec)
-            return false;
-        this.clearTimer(id);
-        await this.redis.srem(LOOP_LIST_KEY, id);
-        await this.redis.del(loopHashKey(id));
-        console.log(`[loop-engine] deleted loop id=${id}`);
-        return true;
-    }
-    /**
-     * Load all active loops from Redis, fire each immediately, then start their timers.
-     * Call once after the bot connects and Redis is ready.
-     */
-    async start() {
-        const ids = await this.redis.smembers(LOOP_LIST_KEY);
-        let started = 0;
-        for (const id of ids) {
-            const rec = await this.loadRecord(id);
-            if (!rec)
-                continue;
-            if (rec.status === "active") {
-                await this.fire(id);
-                this.startTimer(rec);
-                started++;
-            }
-        }
-        console.log(`[loop-engine] started — loaded ${ids.length} loops, started ${started}`);
-    }
-    /**
-     * Stop all running timers. Does not modify Redis.
-     */
-    stop() {
-        for (const [id] of this.timers) {
-            this.clearTimer(id);
-        }
-        console.log("[loop-engine] stopped all timers");
-    }
-    // ─── Private helpers ────────────────────────────────────────────────────────
-    startTimer(rec) {
-        // Clear any existing timer for this ID first
-        this.clearTimer(rec.id);
-        const handle = setInterval(async () => {
-            await this.fire(rec.id);
-        }, rec.intervalMs);
-        this.timers.set(rec.id, handle);
-    }
-    clearTimer(id) {
-        const handle = this.timers.get(id);
-        if (handle !== undefined) {
-            clearInterval(handle);
-            this.timers.delete(id);
-        }
-    }
-    /**
-     * Execute one loop tick:
-     *  1. Reload record (picks up any pause between schedule and fire)
-     *  2. Increment fireCount
-     *  3. Duplicate check against the input queue
-     *  4. Optionally push /compact
-     *  5. Push the message
-     *  6. Update lastRun
-     */
-    async fire(id) {
-        const rec = await this.loadRecord(id);
-        if (!rec) {
-            console.warn(`[loop-engine] fire: record not found for id=${id}`);
-            return;
-        }
-        if (rec.status !== "active") {
-            console.log(`[loop-engine] fire: loop id=${id} is paused — skipping`);
-            return;
-        }
-        const ns = rec.namespace;
-        const inputKey = metaInputKey(ns);
-        // Increment fireCount
-        rec.fireCount += 1;
-        // Duplicate check: skip if the message is already queued
-        try {
-            const queued = await this.redis.lrange(inputKey, 0, -1);
-            const alreadyQueued = queued.some((entry) => {
-                try {
-                    const parsed = JSON.parse(entry);
-                    return parsed.content === rec.message;
-                }
-                catch {
-                    return false;
-                }
-            });
-            if (alreadyQueued) {
-                console.log(`[loop-engine] fire: duplicate detected, skipping push (id=${id} ns=${ns})`);
-                await this.saveRecord(rec);
-                return;
-            }
-        }
-        catch (err) {
-            console.warn(`[loop-engine] fire: duplicate check failed (id=${id}):`, err.message);
-        }
-        // Auto-compact every N fires
-        if (rec.compactEvery > 0 && rec.fireCount % rec.compactEvery === 0) {
-            const compactEntry = JSON.stringify({
-                id: randomUUID(),
-                content: "/compact",
-                timestamp: new Date().toISOString(),
-                source: "loop",
-            });
-            try {
-                await this.redis.rpush(inputKey, compactEntry);
-                console.log(`[loop-engine] fire: pushed /compact (id=${id} ns=${ns} fireCount=${rec.fireCount})`);
-            }
-            catch (err) {
-                console.warn(`[loop-engine] fire: /compact push failed (id=${id}):`, err.message);
-            }
-        }
-        // Push the scheduled message
-        const entry = JSON.stringify({
-            id: randomUUID(),
-            content: rec.message,
-            timestamp: new Date().toISOString(),
-            source: "loop",
-        });
-        try {
-            await this.redis.rpush(inputKey, entry);
-            rec.lastRun = new Date().toISOString();
-            console.log(`[loop-engine] fire: pushed message (id=${id} ns=${ns} fireCount=${rec.fireCount})`);
-            // Record which loop fired for this namespace
-            await this.redis.set(loopPendingKey(ns), id, "EX", 300);
-        }
-        catch (err) {
-            console.warn(`[loop-engine] fire: push failed (id=${id}):`, err.message);
-        }
-        await this.saveRecord(rec);
-    }
-    /** Write a LoopRecord to Redis as a HASH. */
-    async saveRecord(rec) {
-        const key = loopHashKey(rec.id);
-        await this.redis.hset(key, {
-            id: rec.id,
-            namespace: rec.namespace,
-            message: rec.message,
-            interval_ms: String(rec.intervalMs),
-            fire_count: String(rec.fireCount),
-            compact_every: String(rec.compactEvery),
-            status: rec.status,
-            last_run: rec.lastRun,
-            created_at: rec.createdAt,
-        });
-    }
-    /** Load a LoopRecord from Redis. Returns null if the key doesn't exist. */
-    async loadRecord(id) {
-        const data = await this.redis.hgetall(loopHashKey(id));
-        if (!data || !data.id)
-            return null;
-        return {
-            id: data.id,
-            namespace: data.namespace,
-            message: data.message,
-            intervalMs: parseInt(data.interval_ms ?? "0", 10),
-            fireCount: parseInt(data.fire_count ?? "0", 10),
-            compactEvery: parseInt(data.compact_every ?? "10", 10),
-            status: (data.status === "paused" ? "paused" : "active"),
-            lastRun: data.last_run ?? "",
-            createdAt: data.created_at ?? "",
-        };
-    }
-}