@gonzih/cc-discord 0.2.27 → 0.2.29

package/dist/bot.d.ts

@@ -36,6 +36,7 @@ export declare class CcDiscordBot {
     private lastActiveChannelId?;
     private cron;
     private cronEngine?;
+    private loopEngine?;
     private metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     private mcpSession?;
@@ -100,6 +101,12 @@ 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.
@@ -150,6 +157,12 @@ 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,6 +16,7 @@ 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. */
@@ -122,6 +123,7 @@ export class CcDiscordBot {
     lastActiveChannelId;
     cron;
     cronEngine;
+    loopEngine;
     metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     mcpSession;
@@ -132,6 +134,7 @@ 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({
@@ -842,6 +845,28 @@ 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) {
@@ -974,6 +999,8 @@ export class CcDiscordBot {
             }
             case "clear": {
                 const ns = this.resolveNamespaceForChannel(channelId);
+                // Kill the persistent session first so Claude releases the JSONL file
+                this.metaAgentManager.killSession(ns);
                 const deleted = this.clearClaudeSession(ns);
                 await interaction.reply(deleted > 0
                     ? `Context cleared for ${ns} (${deleted} session file${deleted === 1 ? "" : "s"} removed). Next message starts fresh.`
@@ -983,15 +1010,18 @@ export class CcDiscordBot {
             case "compact": {
                 const ns = this.resolveNamespaceForChannel(channelId);
                 await interaction.reply(`Compacting context for ${ns}...`);
-                this.compactClaudeSession(ns).catch((err) => {
-                    console.warn(`[bot] /compact failed (ns=${ns}):`, err.message);
-                });
+                // Send /compact via stdin to the running persistent session
+                this.metaAgentManager.sendToSession(ns, "/compact");
                 break;
             }
             case "cron": {
                 await this.handleCronEngineCommand(interaction, channelId);
                 break;
             }
+            case "loop": {
+                await this.handleLoopEngineCommand(interaction, channelId);
+                break;
+            }
         }
     }
     async handleCronsCommand(interaction, channelId) {
@@ -1113,6 +1143,82 @@ 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.
@@ -1356,6 +1462,18 @@ 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.
@@ -1452,6 +1570,7 @@ export class CcDiscordBot {
             this.stopMetaAgentTyping(channelId);
         }
         this.metaAgentManager.stop();
+        this.loopEngine?.stop();
         void this.client.destroy();
     }
 }

package/dist/index.js

@@ -145,6 +145,8 @@ 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/loop-engine.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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

@@ -0,0 +1,312 @@
+/**
+ * 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 ?? "",
+        };
+    }
+}

package/dist/meta-agent-manager.d.ts

@@ -4,8 +4,13 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. pollQueues (3s interval): wire.discord.dequeue(ns) → spawnSession(ns, content)
- *   4. spawnSession: claude --continue -p "{message}" pipes stdout → wire.discord.publishOutgoing
+ *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
+ *      (no -p flag — messages go via stdin)
+ *   4. On new message: write "${message}\n" to stdin of the running process
+ *   5. On process exit: remove from sessions map; next message respawns
+ *
+ * The polling loop now just drains any queued Redis messages into stdin.
+ * No more per-message process spawn — Claude receives messages in sequence.
  */
 import type { createCcWire } from "@gonzih/cc-wire";
 type Wire = ReturnType<typeof createCcWire>;
@@ -43,6 +48,8 @@ export declare const metaLogKey: (ns: string) => string;
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
  * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
+ *
+ * Kept for backwards-compat and direct integration-test usage.
  */
 export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
 export interface MetaAgentManager {
@@ -53,9 +60,25 @@ export interface MetaAgentManager {
         repoUrl: string;
     }>, instanceId?: string) => void;
     stop: () => void;
+    /** Kill and remove the persistent session for a namespace (e.g. on /clear). */
+    killSession: (ns: string) => void;
+    /** Write a raw line to the stdin of the running session, if any. */
+    sendToSession: (ns: string, line: string) => void;
 }
 /**
- * Create a MetaAgentManager that polls input queues and spawns sessions.
+ * Create a MetaAgentManager that maintains one persistent Claude process per namespace.
+ *
+ * On first message for a namespace:
+ *   1. ensureWorkspace + injectMcp
+ *   2. Drain any pending Redis queue entries to stdin
+ *   3. Write the new message to stdin
+ *
+ * On subsequent messages: write directly to stdin of the running process.
+ *
+ * On process exit: remove from sessions map. Next message triggers a respawn.
+ *
+ * The 3-second poll loop drains any messages that arrived while a session was
+ * starting up or temporarily unavailable.
  */
 export declare function createMetaAgentManager(): MetaAgentManager;
 /**

package/dist/meta-agent-manager.js

@@ -4,8 +4,13 @@
  * Flow per namespace:
  *   1. ensureWorkspace: git clone repo to ~/cc-discord-workspace/{ns}
  *   2. injectMcp: write .mcp.json so the claude subprocess has MCP tool access
- *   3. pollQueues (3s interval): wire.discord.dequeue(ns) → spawnSession(ns, content)
- *   4. spawnSession: claude --continue -p "{message}" pipes stdout → wire.discord.publishOutgoing
+ *   3. ensureSession: spawn one persistent `claude --continue` process per namespace
+ *      (no -p flag — messages go via stdin)
+ *   4. On new message: write "${message}\n" to stdin of the running process
+ *   5. On process exit: remove from sessions map; next message respawns
+ *
+ * The polling loop now just drains any queued Redis messages into stdin.
+ * No more per-message process spawn — Claude receives messages in sequence.
  */
 import { spawn, execSync } from "child_process";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
@@ -124,25 +129,146 @@ function resolveClaude() {
  */
 export const metaStreamChannel = ccWireMetaStreamChannel;
 export const metaLogKey = ccWireMetaLogKey;
+/**
+ * Build the env object for a claude subprocess based on the token type.
+ */
+function buildEnv(token) {
+    const env = { ...process.env };
+    if (token.startsWith("sk-ant-api")) {
+        env.ANTHROPIC_API_KEY = token;
+        delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    }
+    else {
+        env.CLAUDE_CODE_OAUTH_TOKEN = token;
+        delete env.ANTHROPIC_API_KEY;
+    }
+    return env;
+}
+/**
+ * Wire stdout from a claude subprocess into Redis.
+ * Parses JSONL lines from stream-json format, publishes to:
+ *   PUBLISH cca:meta:{ns}:stream
+ *   LPUSH   cca:meta:{ns}:log  (capped at 2000)
+ * Also dispatches assistant/result text to wire.discord.publishOutgoing.
+ */
+function wireStdoutToRedis(proc, ns, wire) {
+    const rawRedis = wire._redis;
+    const streamCh = metaStreamChannel(ns);
+    const logKey = metaLogKey(ns);
+    const forwardEventToRedis = (eventJson) => {
+        rawRedis.publish(streamCh, eventJson).catch((err) => {
+            console.warn(`[meta-agent-manager] stream publish failed (ns=${ns}):`, err.message);
+        });
+        rawRedis.lpush(logKey, eventJson).then(() => {
+            rawRedis.ltrim(logKey, 0, 1999).catch(() => { });
+        }).catch((err) => {
+            console.warn(`[meta-agent-manager] log lpush failed (ns=${ns}):`, err.message);
+        });
+    };
+    const processLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let structuredEvent;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const type = parsed.type;
+            if (type === "assistant") {
+                const content = parsed.message;
+                const textBlock = content?.content?.find((b) => b.type === "text");
+                const text = textBlock?.text ?? "";
+                structuredEvent = { type: "assistant", text };
+                if (text) {
+                    const msg = {
+                        id: crypto.randomUUID(),
+                        source: "claude",
+                        role: "assistant",
+                        content: text,
+                        timestamp: new Date().toISOString(),
+                        chatId: 0,
+                    };
+                    wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                        console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
+                    });
+                }
+            }
+            else if (type === "tool_use") {
+                structuredEvent = {
+                    type: "tool_use",
+                    name: parsed.name ?? "",
+                    input: parsed.input ?? {},
+                };
+            }
+            else if (type === "tool_result") {
+                structuredEvent = {
+                    type: "tool_result",
+                    content: parsed.content ?? "",
+                };
+            }
+            else if (type === "result") {
+                const resultText = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result ?? "");
+                structuredEvent = {
+                    type: "result",
+                    result: resultText,
+                    is_error: parsed.is_error ?? false,
+                };
+                if (resultText) {
+                    const msg = {
+                        id: crypto.randomUUID(),
+                        source: "claude",
+                        role: "assistant",
+                        content: resultText,
+                        timestamp: new Date().toISOString(),
+                        chatId: 0,
+                    };
+                    wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                        console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
+                    });
+                }
+            }
+            else {
+                structuredEvent = parsed;
+            }
+        }
+        catch {
+            structuredEvent = { type: "text", text: trimmed };
+        }
+        forwardEventToRedis(JSON.stringify(structuredEvent));
+    };
+    let lineBuffer = "";
+    proc.stdout.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            processLine(line);
+        }
+    });
+    proc.stderr.on("data", (chunk) => {
+        const text = chunk.toString().trim();
+        if (text)
+            console.log(`[meta-agent-manager:${ns}:stderr] ${text}`);
+    });
+    proc.on("exit", () => {
+        // Flush remaining buffered content
+        if (lineBuffer.trim())
+            processLine(lineBuffer);
+        lineBuffer = "";
+    });
+}
 /**
  * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
  * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
+ *
+ * Kept for backwards-compat and direct integration-test usage.
  */
 export function spawnSession(ns, message, token, wire) {
     return new Promise((resolve, reject) => {
         const wsPath = workspacePath(ns);
         const claudeBin = resolveClaude();
-        const env = { ...process.env };
-        if (token.startsWith("sk-ant-api")) {
-            env.ANTHROPIC_API_KEY = token;
-            delete env.CLAUDE_CODE_OAUTH_TOKEN;
-        }
-        else {
-            env.CLAUDE_CODE_OAUTH_TOKEN = token;
-            delete env.ANTHROPIC_API_KEY;
-        }
+        const env = buildEnv(token);
         const proc = spawn(claudeBin, [
             "--continue",
             "-p", message,
@@ -150,121 +276,8 @@ export function spawnSession(ns, message, token, wire) {
             "--verbose",
             "--dangerously-skip-permissions",
         ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
-        let lineBuffer = "";
-        /**
-         * Parse a JSONL line from claude's stream-json stdout into a structured event.
-         * For lines that fail JSON.parse, emit { type: "text", text: line }.
-         * Forward each event as a JSON string to Redis:
-         *   PUBLISH cca:meta:{ns}:stream
-         *   LPUSH   cca:meta:{ns}:log  (capped at 2000)
-         */
-        const rawRedis = wire._redis;
-        const streamCh = metaStreamChannel(ns);
-        const logKey = metaLogKey(ns);
-        const forwardEventToRedis = (eventJson) => {
-            rawRedis.publish(streamCh, eventJson).catch((err) => {
-                console.warn(`[meta-agent-manager] stream publish failed (ns=${ns}):`, err.message);
-            });
-            rawRedis.lpush(logKey, eventJson).then(() => {
-                rawRedis.ltrim(logKey, 0, 1999).catch(() => { });
-            }).catch((err) => {
-                console.warn(`[meta-agent-manager] log lpush failed (ns=${ns}):`, err.message);
-            });
-        };
-        const processLine = (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return;
-            let structuredEvent;
-            try {
-                const parsed = JSON.parse(trimmed);
-                // Map claude stream-json event shapes to our canonical structured event format
-                const type = parsed.type;
-                if (type === "assistant") {
-                    // Extract text from content blocks
-                    const content = parsed.message;
-                    const textBlock = content?.content?.find((b) => b.type === "text");
-                    const text = textBlock?.text ?? "";
-                    structuredEvent = { type: "assistant", text };
-                    // Also publish to Discord outgoing channel
-                    if (text) {
-                        const msg = {
-                            id: crypto.randomUUID(),
-                            source: "claude",
-                            role: "assistant",
-                            content: text,
-                            timestamp: new Date().toISOString(),
-                            chatId: 0,
-                        };
-                        wire.discord.publishOutgoing(ns, msg).catch((err) => {
-                            console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
-                        });
-                    }
-                }
-                else if (type === "tool_use") {
-                    structuredEvent = {
-                        type: "tool_use",
-                        name: parsed.name ?? "",
-                        input: parsed.input ?? {},
-                    };
-                }
-                else if (type === "tool_result") {
-                    structuredEvent = {
-                        type: "tool_result",
-                        content: parsed.content ?? "",
-                    };
-                }
-                else if (type === "result") {
-                    const resultText = typeof parsed.result === "string" ? parsed.result : JSON.stringify(parsed.result ?? "");
-                    structuredEvent = {
-                        type: "result",
-                        result: resultText,
-                        is_error: parsed.is_error ?? false,
-                    };
-                    // Publish result text to Discord as final assistant message
-                    if (resultText) {
-                        const msg = {
-                            id: crypto.randomUUID(),
-                            source: "claude",
-                            role: "assistant",
-                            content: resultText,
-                            timestamp: new Date().toISOString(),
-                            chatId: 0,
-                        };
-                        wire.discord.publishOutgoing(ns, msg).catch((err) => {
-                            console.warn(`[meta-agent-manager] publishOutgoing (result) failed (ns=${ns}):`, err.message);
-                        });
-                    }
-                }
-                else {
-                    // Forward other event types as-is
-                    structuredEvent = parsed;
-                }
-            }
-            catch {
-                // Non-JSON line — wrap as text event
-                structuredEvent = { type: "text", text: trimmed };
-            }
-            forwardEventToRedis(JSON.stringify(structuredEvent));
-        };
-        proc.stdout.on("data", (chunk) => {
-            lineBuffer += chunk.toString();
-            const lines = lineBuffer.split("\n");
-            lineBuffer = lines.pop() ?? "";
-            for (const line of lines) {
-                processLine(line);
-            }
-        });
-        proc.stderr.on("data", (chunk) => {
-            const text = chunk.toString().trim();
-            if (text)
-                console.log(`[meta-agent-manager:${ns}:stderr] ${text}`);
-        });
+        wireStdoutToRedis(proc, ns, wire);
         proc.on("exit", (code) => {
-            // Flush any remaining buffered content
-            if (lineBuffer.trim())
-                processLine(lineBuffer);
-            lineBuffer = "";
             console.log(`[meta-agent-manager] session exited (ns=${ns}, code=${code})`);
             resolve();
         });
@@ -275,11 +288,144 @@ export function spawnSession(ns, message, token, wire) {
     });
 }
 /**
- * Create a MetaAgentManager that polls input queues and spawns sessions.
+ * Spawn a persistent `claude --continue` process for a namespace.
+ * No -p flag — messages are delivered via stdin.
+ * Stdout is wired to Redis via wireStdoutToRedis.
+ * Returns the ChildProcess.
+ */
+function spawnPersistentSession(ns, token, wire, onExit) {
+    const wsPath = workspacePath(ns);
+    const claudeBin = resolveClaude();
+    const env = buildEnv(token);
+    console.log(`[meta-agent-manager] spawning persistent session (ns=${ns})`);
+    const proc = spawn(claudeBin, [
+        "--continue",
+        "--output-format", "stream-json",
+        "--verbose",
+        "--dangerously-skip-permissions",
+    ], { cwd: wsPath, env, stdio: ["pipe", "pipe", "pipe"] });
+    // Set stdin encoding so we can write strings directly
+    proc.stdin.setDefaultEncoding("utf8");
+    wireStdoutToRedis(proc, ns, wire);
+    proc.on("exit", (code) => {
+        console.log(`[meta-agent-manager] persistent session exited (ns=${ns}, code=${code})`);
+        onExit();
+    });
+    proc.on("error", (err) => {
+        console.error(`[meta-agent-manager] persistent session spawn error (ns=${ns}):`, err.message);
+        onExit();
+    });
+    return proc;
+}
+/**
+ * Create a MetaAgentManager that maintains one persistent Claude process per namespace.
+ *
+ * On first message for a namespace:
+ *   1. ensureWorkspace + injectMcp
+ *   2. Drain any pending Redis queue entries to stdin
+ *   3. Write the new message to stdin
+ *
+ * On subsequent messages: write directly to stdin of the running process.
+ *
+ * On process exit: remove from sessions map. Next message triggers a respawn.
+ *
+ * The 3-second poll loop drains any messages that arrived while a session was
+ * starting up or temporarily unavailable.
  */
 export function createMetaAgentManager() {
     let pollInterval = null;
-    const activeNamespaces = new Set();
+    /** One persistent ChildProcess per namespace. */
+    const sessions = new Map();
+    /** Namespaces currently being set up (workspace clone / first spawn). */
+    const startingUp = new Set();
+    /**
+     * Write a line to the stdin of the persistent session for ns.
+     * Silently no-ops if no session exists.
+     */
+    function writeToStdin(ns, line) {
+        const session = sessions.get(ns);
+        if (!session)
+            return;
+        try {
+            session.proc.stdin.write(`${line}\n`);
+        }
+        catch (err) {
+            console.warn(`[meta-agent-manager] stdin write failed (ns=${ns}):`, err.message);
+        }
+    }
+    /**
+     * Drain all pending messages from the Redis input queue into the session's stdin.
+     */
+    async function drainQueue(ns, wire) {
+        const inputKey = discordMetaInputKey(ns);
+        for (;;) {
+            let raw;
+            try {
+                raw = await wire._redis.lpop(inputKey);
+            }
+            catch {
+                break;
+            }
+            if (!raw)
+                break;
+            let content;
+            try {
+                content = JSON.parse(raw).content ?? raw;
+            }
+            catch {
+                content = raw;
+            }
+            writeToStdin(ns, content);
+        }
+    }
+    /**
+     * Ensure a persistent session exists for ns.
+     * If one already exists, returns immediately.
+     * If not, spawns one, drains any queued messages, then writes `firstMessage` if provided.
+     */
+    async function ensureSession(ns, repoUrl, token, wire, firstMessage) {
+        if (sessions.has(ns)) {
+            if (firstMessage !== undefined)
+                writeToStdin(ns, firstMessage);
+            return;
+        }
+        if (startingUp.has(ns)) {
+            // Already spinning up — queue the message so drainQueue picks it up
+            return;
+        }
+        startingUp.add(ns);
+        try {
+            // Ensure workspace exists
+            const wsPath = workspacePath(ns);
+            await ensureWorkspace(ns, repoUrl);
+            injectMcp(ns, wsPath, token);
+            const proc = spawnPersistentSession(ns, token, wire, () => {
+                // On exit: remove from map so next message triggers a respawn
+                sessions.delete(ns);
+                console.log(`[meta-agent-manager] session removed from map (ns=${ns})`);
+            });
+            sessions.set(ns, { proc, ns });
+            // Drain any messages that arrived before this session started
+            await drainQueue(ns, wire);
+            // Write the triggering message last (after queue drain, in order)
+            if (firstMessage !== undefined)
+                writeToStdin(ns, firstMessage);
+            await wire.discord.setStatus(ns, {
+                namespace: ns,
+                status: "running",
+                isTyping: true,
+                turnCount: 0,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[meta-agent-manager] ensureSession failed (ns=${ns}):`, err.message);
+            sessions.delete(ns);
+        }
+        finally {
+            startingUp.delete(ns);
+        }
+    }
     return {
         async ensureWorkspace(ns, repoUrl) {
             await ensureWorkspace(ns, repoUrl);
@@ -296,34 +442,28 @@ export function createMetaAgentManager() {
                 if (namespaces.length === 0)
                     return;
                 for (const { namespace: ns, repoUrl } of namespaces) {
-                    if (activeNamespaces.has(ns))
-                        continue;
-                    wire.discord.dequeue(ns)
-                        .then(async (msg) => {
-                        if (!msg)
-                            return;
-                        // Staleness check: if a newer instance has registered, this process is stale — exit.
-                        if (instanceId) {
-                            try {
-                                const current = await wire._redis.get(DISCORD_INSTANCE_KEY);
-                                if (current && current !== instanceId) {
-                                    console.log(`[meta-agent-manager] stale instance detected (current=${current}, ours=${instanceId}) — exiting`);
-                                    process.exit(0);
-                                }
+                    // Stale-instance check
+                    if (instanceId) {
+                        wire._redis.get(DISCORD_INSTANCE_KEY).then((current) => {
+                            if (current && current !== instanceId) {
+                                console.log(`[meta-agent-manager] stale instance detected (current=${current}, ours=${instanceId}) — exiting`);
+                                process.exit(0);
                             }
-                            catch {
-                                // Redis error — proceed anyway
-                            }
-                        }
-                        const content = typeof msg === "string" ? msg : msg.content ?? String(msg);
-                        activeNamespaces.add(ns);
-                        await wire.discord.setStatus(ns, {
-                            namespace: ns,
-                            status: "running",
-                            isTyping: true,
-                            turnCount: 0,
-                            updatedAt: new Date().toISOString(),
+                        }).catch(() => { });
+                    }
+                    // If session exists, drain any queued messages
+                    if (sessions.has(ns)) {
+                        drainQueue(ns, wire).catch((err) => {
+                            console.warn(`[meta-agent-manager] drainQueue error (ns=${ns}):`, err.message);
                         });
+                        continue;
+                    }
+                    // Check if anything is queued for this namespace
+                    const inputKey = discordMetaInputKey(ns);
+                    wire._redis.llen(inputKey).then(async (queueLen) => {
+                        if (queueLen === 0)
+                            return;
+                        // Resolve token
                         let token;
                         try {
                             token = await wire.token.getMaster();
@@ -336,38 +476,12 @@ export function createMetaAgentManager() {
                         }
                         if (!token) {
                             console.warn(`[meta-agent-manager] no token available, skipping session for ns=${ns}`);
-                            activeNamespaces.delete(ns);
-                            await wire.discord.setStatus(ns, {
-                                namespace: ns,
-                                status: "idle",
-                                isTyping: false,
-                                turnCount: 0,
-                                updatedAt: new Date().toISOString(),
-                            });
                             return;
                         }
-                        // Ensure the workspace directory exists — idempotent if already cloned.
-                        // This guards against the workspace being absent after a bot restart.
-                        const wsPath = workspacePath(ns);
-                        await ensureWorkspace(ns, repoUrl);
-                        injectMcp(ns, wsPath, token);
-                        spawnSession(ns, content, token, wire)
-                            .catch((err) => {
-                            console.error(`[meta-agent-manager] session error (ns=${ns}):`, err.message);
-                        })
-                            .finally(() => {
-                            activeNamespaces.delete(ns);
-                            wire.discord.setStatus(ns, {
-                                namespace: ns,
-                                status: "idle",
-                                isTyping: false,
-                                turnCount: 0,
-                                updatedAt: new Date().toISOString(),
-                            }).catch(() => { });
-                        });
-                    })
-                        .catch((err) => {
-                        console.warn(`[meta-agent-manager] dequeue error (ns=${ns}):`, err.message);
+                        // ensureSession will drain the queue itself
+                        await ensureSession(ns, repoUrl, token, wire);
+                    }).catch((err) => {
+                        console.warn(`[meta-agent-manager] llen error (ns=${ns}):`, err.message);
                     });
                 }
             }, TIMING.INPUT_POLL_INTERVAL_MS);
@@ -379,6 +493,35 @@ export function createMetaAgentManager() {
                 pollInterval = null;
                 console.log("[meta-agent-manager] polling stopped");
             }
+            // Kill all active sessions
+            for (const [ns, session] of sessions) {
+                try {
+                    session.proc.stdin.end();
+                    session.proc.kill();
+                }
+                catch {
+                    // ignore errors during shutdown
+                }
+                sessions.delete(ns);
+                console.log(`[meta-agent-manager] killed session on stop (ns=${ns})`);
+            }
+        },
+        killSession(ns) {
+            const session = sessions.get(ns);
+            if (!session)
+                return;
+            try {
+                session.proc.stdin.end();
+                session.proc.kill();
+            }
+            catch {
+                // ignore
+            }
+            sessions.delete(ns);
+            console.log(`[meta-agent-manager] killed session (ns=${ns})`);
+        },
+        sendToSession(ns, line) {
+            writeToStdin(ns, line);
         },
     };
 }

package/dist/notifier.js

@@ -112,17 +112,14 @@ 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 (routingArr && routingArr.length > 0 && !routingArr.includes("discord")) {
+        if (parsed.routing && parsed.routing.length > 0 && !parsed.routing.includes("discord")) {
             return null;
         }
         if (parsed.is_cron === true)
             return null;
-        // Accept 'message' as alias for 'text'
-        if (parsed.text ?? parsed.message)
-            text = (parsed.text ?? parsed.message);
+        if (parsed.text)
+            text = parsed.text;
         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.27",
+  "version": "0.2.29",
   "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.0",
+    "@gonzih/cc-wire": "^0.4.1",
     "@types/node-cron": "^3.0.11",
     "discord.js": "^14.0.0",
     "ioredis": "^5.0.0",