@gonzih/cc-discord 0.1.17 → 0.2.0

package/dist/bot.d.ts

@@ -29,9 +29,11 @@ export declare class CcDiscordBot {
     private costs;
     private opts;
     private redis?;
+    private wire?;
     private namespace;
     private lastActiveChannelId?;
     private cron;
+    private metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     private mcpSession?;
     constructor(opts: DiscordBotOptions);
@@ -41,7 +43,7 @@ export declare class CcDiscordBot {
     private channelNamespaceMap;
     private storeSnowflake;
     reverseSnowflakeLookup(n: number): string | undefined;
-    /** Persist a channelId → {namespace, repoUrl} mapping to Redis. */
+    /** Persist a channelId → {namespace, repoUrl} mapping to Redis via wire.discord. */
     private persistChannelMapping;
     /**
      * Load persisted channel→namespace mappings from Redis and repopulate
@@ -104,5 +106,13 @@ export declare class CcDiscordBot {
      * Unlike handleUserMessage, this never creates a new session.
      */
     forwardNotification(channelId: string, text: string): void;
+    /** Resolve the current claude token from wire master or env fallbacks. */
+    resolveToken(): Promise<string>;
+    /**
+     * Start the meta-agent polling loop.
+     * Called from index.ts after startup migrations complete.
+     * Passes a live getter for the set of registered namespaces.
+     */
+    startMetaAgentPolling(): void;
     stop(): void;
 }

package/dist/bot.js

@@ -7,17 +7,15 @@ import { existsSync, createWriteStream, mkdirSync } from "fs";
 import { resolve, basename, join } from "path";
 import https from "https";
 import http from "http";
+import { createCcWire } from "@gonzih/cc-wire";
 import { ClaudeProcess, extractText } from "./claude.js";
 import { transcribeVoice, isVoiceAvailable } from "./voice.js";
 import { formatForDiscord, splitLongMessage, stripAnsi } from "./formatter.js";
 import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
 import { CronManager } from "./cron.js";
-import { parseChannelCreateIntent, ensureMetaAgent, routeToMetaAgent } from "./router.js";
-/** Redis key for persisting a Discord channelId → namespace mapping across restarts. */
-function discordChannelKey(channelId) {
-    return `cca:discord:channel:${channelId}`;
-}
+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. */
 function snowflakeToInt(id) {
     // Discord snowflakes are up to 2^63, beyond Number.MAX_SAFE_INTEGER.
@@ -117,15 +115,21 @@ export class CcDiscordBot {
     costs = new Map();
     opts;
     redis;
+    wire;
     namespace;
     lastActiveChannelId;
     cron;
+    metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     mcpSession;
     constructor(opts) {
         this.opts = opts;
         this.redis = opts.redis;
         this.namespace = opts.namespace ?? "default";
+        if (opts.redis) {
+            this.wire = createCcWire(opts.redis);
+        }
+        this.metaAgentManager = createMetaAgentManager();
         this.client = new Client({
             intents: [
                 GatewayIntentBits.Guilds,
@@ -183,13 +187,11 @@ export class CcDiscordBot {
     reverseSnowflakeLookup(n) {
         return this.snowflakeMap.get(n);
     }
-    /** Persist a channelId → {namespace, repoUrl} mapping to Redis. */
+    /** Persist a channelId → {namespace, repoUrl} mapping to Redis via wire.discord. */
     persistChannelMapping(channelId, namespace, repoUrl) {
-        if (!this.redis)
+        if (!this.wire)
             return;
-        const key = discordChannelKey(channelId);
-        const value = JSON.stringify({ namespace, repoUrl });
-        this.redis.set(key, value).catch((err) => {
+        this.wire.discord.registerChannel(channelId, namespace, repoUrl).catch((err) => {
             console.warn(`[bot] persistChannelMapping failed for ${channelId}:`, err.message);
         });
     }
@@ -198,31 +200,21 @@ export class CcDiscordBot {
      * channelNamespaceMap + routedChannelIds. Call once on startup after the notifier is ready.
      */
     async loadChannelMappings() {
-        if (!this.redis)
+        if (!this.wire)
             return;
-        let keys;
+        let channels;
         try {
-            keys = await this.redis.keys("cca:discord:channel:*");
+            channels = await this.wire.discord.listChannels();
         }
         catch (err) {
-            console.warn("[bot] loadChannelMappings keys scan failed:", err.message);
+            console.warn("[bot] loadChannelMappings failed:", err.message);
             return;
         }
-        for (const key of keys) {
-            try {
-                const raw = await this.redis.get(key);
-                if (!raw)
-                    continue;
-                const { namespace, repoUrl } = JSON.parse(raw);
-                const channelId = key.slice("cca:discord:channel:".length);
-                if (!this.channelNamespaceMap.has(channelId)) {
-                    this.channelNamespaceMap.set(channelId, { namespace, repoUrl });
-                    this.opts.registerRoutedChannelId?.(namespace, channelId);
-                    console.log(`[bot] restored channel mapping: ${channelId} → ${namespace}`);
-                }
-            }
-            catch (err) {
-                console.warn(`[bot] loadChannelMappings: failed to parse ${key}:`, err.message);
+        for (const { channelId, namespace, repoUrl } of channels) {
+            if (!this.channelNamespaceMap.has(channelId)) {
+                this.channelNamespaceMap.set(channelId, { namespace, repoUrl });
+                this.opts.registerRoutedChannelId?.(namespace, channelId);
+                console.log(`[bot] restored channel mapping: ${channelId} → ${namespace}`);
             }
         }
     }
@@ -832,14 +824,16 @@ export class CcDiscordBot {
                     this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
                     this.persistChannelMapping(newChannel.id, namespace, repoUrl);
                     await interaction.editReply(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`);
-                    // Start meta-agent in the background
-                    if (this.redis) {
-                        ensureMetaAgent(namespace, repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis)
-                            .catch((err) => {
-                            console.error(`[bot] /channel ensureMetaAgent(${namespace}) failed:`, err.message);
-                            this.sendToChannelById(newChannel.id, `Warning: meta-agent startup failed — ${err.message}`).catch(() => { });
-                        });
-                    }
+                    // Clone workspace and inject MCP config in the background
+                    this.metaAgentManager.ensureWorkspace(namespace, repoUrl)
+                        .then(async () => {
+                        const token = await this.resolveToken();
+                        this.metaAgentManager.injectMcp(namespace, token);
+                    })
+                        .catch((err) => {
+                        console.error(`[bot] /channel workspace setup(${namespace}) failed:`, err.message);
+                        this.sendToChannelById(newChannel.id, `Warning: workspace setup failed — ${err.message}`).catch(() => { });
+                    });
                 }
                 catch (err) {
                     await interaction.editReply(`Failed to create channel: ${err.message}`);
@@ -976,14 +970,16 @@ export class CcDiscordBot {
         this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
         this.persistChannelMapping(newChannel.id, namespace, repoUrl);
         await channel.send(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`).catch(() => { });
-        // Start meta-agent in the background after acknowledging the user
-        if (this.redis) {
-            ensureMetaAgent(namespace, repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis)
-                .catch((err) => {
-                console.error(`[bot] ensureMetaAgent(${namespace}) failed:`, err.message);
-                this.sendToChannelById(newChannel.id, `Warning: meta-agent startup failed — ${err.message}`).catch(() => { });
-            });
-        }
+        // Clone workspace and inject MCP config in the background after acknowledging the user
+        this.metaAgentManager.ensureWorkspace(namespace, repoUrl)
+            .then(async () => {
+            const token = await this.resolveToken();
+            this.metaAgentManager.injectMcp(namespace, token);
+        })
+            .catch((err) => {
+            console.error(`[bot] workspace setup(${namespace}) failed:`, err.message);
+            this.sendToChannelById(newChannel.id, `Warning: workspace setup failed — ${err.message}`).catch(() => { });
+        });
     }
     /** Write a message to the Redis chat log. Fire-and-forget.
      *  Pass `ns` to write under a specific namespace; defaults to the bot's primary namespace. */
@@ -1043,6 +1039,32 @@ export class CcDiscordBot {
             console.error(`[forwardNotification:${channelId}] failed:`, err.message);
         }
     }
+    /** Resolve the current claude token from wire master or env fallbacks. */
+    async resolveToken() {
+        if (this.wire) {
+            try {
+                return await this.wire.token.getMaster();
+            }
+            catch {
+                // master token not set — fall through to env vars
+            }
+        }
+        return (this.opts.claudeToken ??
+            process.env.CLAUDE_CODE_OAUTH_TOKEN ??
+            process.env.CLAUDE_CODE_TOKEN ??
+            process.env.ANTHROPIC_API_KEY ??
+            "");
+    }
+    /**
+     * Start the meta-agent polling loop.
+     * Called from index.ts after startup migrations complete.
+     * Passes a live getter for the set of registered namespaces.
+     */
+    startMetaAgentPolling() {
+        if (!this.wire)
+            return;
+        this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()).map((v) => v.namespace));
+    }
     stop() {
         for (const [key, session] of this.sessions) {
             if (session.flushTimer)
@@ -1055,6 +1077,7 @@ export class CcDiscordBot {
         for (const [channelId] of this.metaAgentTypingTimers) {
             this.stopMetaAgentTyping(channelId);
         }
+        this.metaAgentManager.stop();
         void this.client.destroy();
     }
 }

package/dist/index.d.ts

@@ -13,9 +13,10 @@
  *   DISCORD_GUILD_IDS          — comma-separated Discord guild/server IDs (for instant slash command registration)
  *   DISCORD_ALLOWED_USER_IDS   — comma-separated Discord user IDs to whitelist (leave empty to allow all)
  *   DISCORD_NOTIFY_CHANNEL_ID  — Discord channel ID for job notifications
- *   CC_AGENT_NAMESPACE         — cc-agent namespace (default: money-brain)
+ *   CC_AGENT_NAMESPACE         — primary namespace (default: money-brain)
  *   REDIS_URL                  — Redis connection URL (default: redis://localhost:6379)
  *   CWD                        — working directory for Claude Code (default: process.cwd())
  *   DEFAULT_GITHUB_ORG         — default GitHub org for #repo routing (default: gonzih)
+ *   CC_DISCORD_MCP_JSON        — JSON template for .mcp.json injection into workspaces
  */
 export {};

package/dist/index.js

@@ -13,16 +13,19 @@
  *   DISCORD_GUILD_IDS          — comma-separated Discord guild/server IDs (for instant slash command registration)
  *   DISCORD_ALLOWED_USER_IDS   — comma-separated Discord user IDs to whitelist (leave empty to allow all)
  *   DISCORD_NOTIFY_CHANNEL_ID  — Discord channel ID for job notifications
- *   CC_AGENT_NAMESPACE         — cc-agent namespace (default: money-brain)
+ *   CC_AGENT_NAMESPACE         — primary namespace (default: money-brain)
  *   REDIS_URL                  — Redis connection URL (default: redis://localhost:6379)
  *   CWD                        — working directory for Claude Code (default: process.cwd())
  *   DEFAULT_GITHUB_ORG         — default GitHub org for #repo routing (default: gonzih)
+ *   CC_DISCORD_MCP_JSON        — JSON template for .mcp.json injection into workspaces
  */
 import { createRequire } from "node:module";
 import { Redis } from "ioredis";
+import { createCcWire } from "@gonzih/cc-wire";
 import { CcDiscordBot } from "./bot.js";
 import { startNotifier } from "./notifier.js";
 import { loadTokens } from "./tokens.js";
+import { migrateMetaInputKeys } from "./meta-agent-manager.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 function required(name) {
@@ -72,13 +75,59 @@ const sharedRedis = new Redis(redisUrl);
 sharedRedis.on("error", (err) => {
     console.warn("[redis] connection error:", err.message);
 });
+// cc-wire factory
+const wire = createCcWire(sharedRedis);
 sharedRedis.once("ready", () => {
-    // Announce this version on Redis so other services can discover cc-discord
+    // Announce version
     sharedRedis.set(`cca:meta:cc-discord:version`, version).catch((err) => {
         console.warn("[redis] failed to write version:", err.message);
     });
     console.log(`[cc-discord] version:reported ${version}`);
+    // Store master token so MetaAgentManager can retrieve it
+    wire.token.setMaster(claudeToken).catch((err) => {
+        console.warn("[cc-discord] failed to set master token:", err.message);
+    });
+    // Run startup migrations (async, best-effort)
+    void runStartupMigrations();
 });
+/**
+ * Migrate old Redis data formats to the v0.2.0 layout.
+ * Runs once per startup.
+ */
+async function runStartupMigrations() {
+    // 1. Migrate old STRING channel keys to new HSET format
+    let stringKeys;
+    try {
+        stringKeys = await sharedRedis.keys("cca:discord:channel:*");
+    }
+    catch (err) {
+        console.warn("[cc-discord] channel key scan failed:", err.message);
+        stringKeys = [];
+    }
+    for (const key of stringKeys) {
+        try {
+            const type = await sharedRedis.type(key);
+            if (type !== "string")
+                continue; // already migrated or different type
+            const raw = await sharedRedis.get(key);
+            if (!raw)
+                continue;
+            const { namespace: ns, repoUrl } = JSON.parse(raw);
+            const channelId = key.slice("cca:discord:channel:".length);
+            await wire.discord.registerChannel(channelId, ns, repoUrl);
+            await sharedRedis.del(key);
+            console.log(`[cc-discord] migrated channel key ${channelId} → HSET`);
+        }
+        catch (err) {
+            console.warn(`[cc-discord] channel key migration failed for ${key}:`, err.message);
+        }
+    }
+    // 2. Migrate old meta input keys (cca:meta:{ns}:input → cca:discord:meta:{ns}:input)
+    await migrateMetaInputKeys(sharedRedis);
+    console.log("[cc-discord] startup migrations complete");
+    // 3. Start meta-agent polling now that data is migrated
+    bot.startMetaAgentPolling();
+}
 // Mutable placeholder closures — filled in once `bot` is created below
 let getLastActiveChannelIdFn = () => undefined;
 let handleUserMessageFn;

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

@@ -0,0 +1,61 @@
+/**
+ * MetaAgentManager — cc-discord owns Claude session lifecycle for routed namespaces.
+ *
+ * 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
+ */
+import type { createCcWire } from "@gonzih/cc-wire";
+type Wire = ReturnType<typeof createCcWire>;
+/**
+ * Returns the path to the workspace for the given namespace.
+ * Creates the parent root directory if needed.
+ */
+export declare function workspacePath(ns: string): string;
+/**
+ * Clone the repo to ~/cc-discord-workspace/{ns} if not already present.
+ * No-op if the directory already exists.
+ */
+export declare function ensureWorkspace(ns: string, repoUrl: string): Promise<void>;
+/**
+ * Write .mcp.json to the workspace so the claude session has MCP tool access.
+ *
+ * Template priority:
+ *   1. CC_DISCORD_MCP_JSON env var (full JSON string) — operator-supplied override
+ *   2. Built-in template: cc-agent MCP server with namespace-scoped env
+ *
+ * Variables substituted in the template: {namespace}, {workspacePath}, {token},
+ * {npmCache}, {trustedOwners}, {path}.
+ */
+export declare function injectMcp(ns: string, wsPath: string, token: string): void;
+/**
+ * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
+ * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Returns a Promise that resolves when the process exits.
+ */
+export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
+export interface MetaAgentManager {
+    ensureWorkspace: (ns: string, repoUrl: string) => Promise<void>;
+    injectMcp: (ns: string, token: string) => void;
+    startPolling: (wire: Wire, getNamespaces: () => string[]) => void;
+    stop: () => void;
+}
+/**
+ * Create a MetaAgentManager that polls input queues and spawns sessions.
+ */
+export declare function createMetaAgentManager(): MetaAgentManager;
+/**
+ * Migrate the old cc-agent meta input key to the new cc-discord key.
+ * Old: cca:meta:{ns}:input → New: cca:discord:meta:{ns}:input
+ *
+ * Called once on startup.
+ */
+export declare function migrateMetaInputKeys(redis: {
+    keys: (p: string) => Promise<string[]>;
+    lrange: (k: string, s: number, e: number) => Promise<string[]>;
+    rpush: (k: string, ...v: string[]) => Promise<number>;
+    del: (k: string) => Promise<number>;
+}): Promise<void>;
+export {};

package/dist/meta-agent-manager.js

@@ -0,0 +1,296 @@
+/**
+ * MetaAgentManager — cc-discord owns Claude session lifecycle for routed namespaces.
+ *
+ * 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
+ */
+import { spawn, execSync } from "child_process";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { CC_DISCORD_WORKSPACE_ROOT, TIMING, discordMetaInputKey, } from "@gonzih/cc-wire";
+const WORKSPACE_ROOT = join(homedir(), CC_DISCORD_WORKSPACE_ROOT);
+/**
+ * Returns the path to the workspace for the given namespace.
+ * Creates the parent root directory if needed.
+ */
+export function workspacePath(ns) {
+    return join(WORKSPACE_ROOT, ns);
+}
+/**
+ * Clone the repo to ~/cc-discord-workspace/{ns} if not already present.
+ * No-op if the directory already exists.
+ */
+export async function ensureWorkspace(ns, repoUrl) {
+    const wsPath = workspacePath(ns);
+    if (existsSync(wsPath)) {
+        console.log(`[meta-agent-manager] workspace exists: ${wsPath}`);
+        return;
+    }
+    mkdirSync(WORKSPACE_ROOT, { recursive: true });
+    console.log(`[meta-agent-manager] cloning ${repoUrl} → ${wsPath}`);
+    execSync(`git clone ${repoUrl} ${wsPath}`, { stdio: "pipe" });
+    console.log(`[meta-agent-manager] clone complete for namespace=${ns}`);
+}
+/**
+ * Write .mcp.json to the workspace so the claude session has MCP tool access.
+ *
+ * Template priority:
+ *   1. CC_DISCORD_MCP_JSON env var (full JSON string) — operator-supplied override
+ *   2. Built-in template: cc-agent MCP server with namespace-scoped env
+ *
+ * Variables substituted in the template: {namespace}, {workspacePath}, {token},
+ * {npmCache}, {trustedOwners}, {path}.
+ */
+export function injectMcp(ns, wsPath, token) {
+    const mcpPath = join(wsPath, ".mcp.json");
+    if (process.env.CC_DISCORD_MCP_JSON) {
+        const rendered = process.env.CC_DISCORD_MCP_JSON
+            .replace(/\{namespace\}/g, ns)
+            .replace(/\{workspacePath\}/g, wsPath)
+            .replace(/\{token\}/g, token);
+        writeFileSync(mcpPath, rendered, "utf8");
+        console.log(`[meta-agent-manager] injected MCP config (from CC_DISCORD_MCP_JSON) for ${ns}`);
+        return;
+    }
+    const npmCache = process.env.npm_config_cache ?? `${homedir()}/.npm`;
+    const trustedOwners = process.env.CC_AGENT_TRUSTED_OWNERS ?? "";
+    const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    const config = {
+        mcpServers: {
+            "cc-agent": {
+                command: "/opt/homebrew/bin/npx",
+                args: ["-y", "--prefer-online", "@gonzih/cc-agent"],
+                env: {
+                    CC_AGENT_NAMESPACE: ns,
+                    CWD: wsPath,
+                    CLAUDE_CODE_OAUTH_TOKEN: token,
+                    CLAUDE_TOKENS: token,
+                    CC_AGENT_TRUSTED_OWNERS: trustedOwners,
+                    PATH: systemPath,
+                    npm_config_cache: npmCache,
+                },
+            },
+        },
+    };
+    writeFileSync(mcpPath, JSON.stringify(config, null, 2), "utf8");
+    console.log(`[meta-agent-manager] injected MCP config for namespace=${ns}`);
+}
+/**
+ * Resolve claude binary — same logic as claude.ts resolveClaude.
+ */
+function resolveClaude() {
+    const dirs = (process.env.PATH ?? "").split(":");
+    for (const dir of dirs) {
+        const c = `${dir}/claude`;
+        if (existsSync(c))
+            return c;
+    }
+    const fallbacks = [
+        `${homedir()}/.npm-global/bin/claude`,
+        "/opt/homebrew/bin/claude",
+        "/usr/local/bin/claude",
+        "/usr/bin/claude",
+    ];
+    for (const p of fallbacks) {
+        if (existsSync(p))
+            return p;
+    }
+    return "claude";
+}
+/**
+ * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
+ * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Returns a Promise that resolves when the process exits.
+ */
+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 proc = spawn(claudeBin, [
+            "--continue",
+            "-p", message,
+            "--output-format", "text",
+            "--dangerously-skip-permissions",
+        ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
+        let lineBuffer = "";
+        const publishLine = (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            const msg = {
+                id: crypto.randomUUID(),
+                source: "claude",
+                role: "assistant",
+                content: trimmed,
+                timestamp: new Date().toISOString(),
+                chatId: 0,
+            };
+            wire.discord.publishOutgoing(ns, msg).catch((err) => {
+                console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
+            });
+        };
+        proc.stdout.on("data", (chunk) => {
+            lineBuffer += chunk.toString();
+            const lines = lineBuffer.split("\n");
+            lineBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+                publishLine(line);
+            }
+        });
+        proc.stderr.on("data", (chunk) => {
+            const text = chunk.toString().trim();
+            if (text)
+                console.log(`[meta-agent-manager:${ns}:stderr] ${text}`);
+        });
+        proc.on("exit", (code) => {
+            // Flush any remaining buffered content
+            if (lineBuffer.trim())
+                publishLine(lineBuffer);
+            lineBuffer = "";
+            console.log(`[meta-agent-manager] session exited (ns=${ns}, code=${code})`);
+            resolve();
+        });
+        proc.on("error", (err) => {
+            console.error(`[meta-agent-manager] spawn error (ns=${ns}):`, err.message);
+            reject(err);
+        });
+    });
+}
+/**
+ * Create a MetaAgentManager that polls input queues and spawns sessions.
+ */
+export function createMetaAgentManager() {
+    let pollInterval = null;
+    const activeNamespaces = new Set();
+    return {
+        async ensureWorkspace(ns, repoUrl) {
+            await ensureWorkspace(ns, repoUrl);
+        },
+        injectMcp(ns, token) {
+            const wsPath = workspacePath(ns);
+            injectMcp(ns, wsPath, token);
+        },
+        startPolling(wire, getNamespaces) {
+            if (pollInterval)
+                return; // already running
+            pollInterval = setInterval(() => {
+                const namespaces = getNamespaces();
+                if (namespaces.length === 0)
+                    return;
+                for (const ns of namespaces) {
+                    if (activeNamespaces.has(ns))
+                        continue;
+                    wire.discord.dequeue(ns)
+                        .then(async (msg) => {
+                        if (!msg)
+                            return;
+                        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(),
+                        });
+                        let token;
+                        try {
+                            token = await wire.token.getMaster();
+                        }
+                        catch {
+                            token = process.env.CLAUDE_CODE_OAUTH_TOKEN
+                                ?? process.env.CLAUDE_CODE_TOKEN
+                                ?? process.env.ANTHROPIC_API_KEY
+                                ?? "";
+                        }
+                        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;
+                        }
+                        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);
+                    });
+                }
+            }, TIMING.INPUT_POLL_INTERVAL_MS);
+            console.log(`[meta-agent-manager] polling started (interval=${TIMING.INPUT_POLL_INTERVAL_MS}ms)`);
+        },
+        stop() {
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+                console.log("[meta-agent-manager] polling stopped");
+            }
+        },
+    };
+}
+/**
+ * Migrate the old cc-agent meta input key to the new cc-discord key.
+ * Old: cca:meta:{ns}:input → New: cca:discord:meta:{ns}:input
+ *
+ * Called once on startup.
+ */
+export async function migrateMetaInputKeys(redis) {
+    let oldKeys;
+    try {
+        oldKeys = await redis.keys("cca:meta:*:input");
+    }
+    catch (err) {
+        console.warn("[meta-agent-manager] migrateMetaInputKeys keys scan failed:", err.message);
+        return;
+    }
+    for (const key of oldKeys) {
+        const match = key.match(/^cca:meta:(.+):input$/);
+        if (!match)
+            continue;
+        const ns = match[1];
+        const newKey = discordMetaInputKey(ns);
+        try {
+            const items = await redis.lrange(key, 0, -1);
+            if (items.length > 0) {
+                // lrange returns newest-first; reverse to maintain enqueue order
+                await redis.rpush(newKey, ...items.reverse());
+                console.log(`[meta-agent-manager] migrated ${items.length} items: ${key} → ${newKey}`);
+            }
+            await redis.del(key);
+        }
+        catch (err) {
+            console.warn(`[meta-agent-manager] migration failed for ${key}:`, err.message);
+        }
+    }
+}

package/dist/notifier.d.ts

@@ -1,14 +1,14 @@
 /**
  * DiscordNotifier — subscribes to Redis pub/sub channels and bridges messages to Discord.
  *
- * Channels:
- *   cca:notify:{namespace}        — job completion notifications from cc-agent → forward to DISCORD_NOTIFY_CHANNEL_ID
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Discord + feed into Claude session
- *   cca:chat:outgoing:*           — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
+ * v0.2.0 channels (discord-scoped):
+ *   cca:discord:notify:{ns}              — job completion notifications → forward to Discord channel
+ *   cca:chat:incoming:{ns}              — messages from the web UI → echo to Discord + feed to meta-agent
+ *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
  *
  * All messages (Discord incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}      — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
+ *   cca:discord:chat:log:{ns}           — LPUSH + LTRIM 0 499 (last 500 messages)
+ *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
 import { Redis } from "ioredis";
 import type { CcDiscordBot } from "./bot.js";
@@ -34,6 +34,7 @@ export interface ParsedNotification {
 export declare function parseNotification(raw: string): ParsedNotification | null;
 /**
  * Write a message to the chat log in Redis.
+ * Uses discord-scoped keys (cca:discord:chat:log:{ns}, cca:discord:chat:outgoing:{ns}).
  * Fire-and-forget — errors are logged but not thrown.
  */
 export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
@@ -48,7 +49,7 @@ export interface NotifierHandle {
      * Register the originating Discord channel ID for a routed namespace.
      * When the meta-agent for `namespace` publishes a response, it will be
      * forwarded to `channelId`.
-     * Also subscribes to notifyChannel(namespace) and chatIncomingChannel(namespace)
+     * Also subscribes to discordNotify(namespace) and chatIncomingChannel(namespace)
      * so notifications and UI messages for that namespace are received.
      */
     registerRoutedChannelId: (namespace: string, channelId: string) => void;
@@ -58,7 +59,7 @@ export interface NotifierHandle {
  *
  * @param bot                     - CcDiscordBot instance (for sending messages)
  * @param notifyChannelId         - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace               - cc-agent namespace (used to build Redis channel names)
+ * @param namespace               - primary namespace (used to build Redis channel names)
  * @param redis                   - ioredis client in normal mode (will be duplicated for pub/sub)
  * @param handleUserMessage       - Optional callback to feed UI messages into the active Claude session
  * @param forwardNotification     - Optional callback to forward job notifications

package/dist/notifier.js

@@ -1,16 +1,16 @@
 /**
  * DiscordNotifier — subscribes to Redis pub/sub channels and bridges messages to Discord.
  *
- * Channels:
- *   cca:notify:{namespace}        — job completion notifications from cc-agent → forward to DISCORD_NOTIFY_CHANNEL_ID
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Discord + feed into Claude session
- *   cca:chat:outgoing:*           — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
+ * v0.2.0 channels (discord-scoped):
+ *   cca:discord:notify:{ns}              — job completion notifications → forward to Discord channel
+ *   cca:chat:incoming:{ns}              — messages from the web UI → echo to Discord + feed to meta-agent
+ *   cca:discord:chat:outgoing:{ns}      — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
  *
  * All messages (Discord incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}      — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
+ *   cca:discord:chat:log:{ns}           — LPUSH + LTRIM 0 499 (last 500 messages)
+ *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
-import { chatLogKey, chatOutgoingChannel, chatIncomingChannel, notifyChannel, notifyListKey, metaAgentStatusKey, metaInputKey, } from "@gonzih/cc-wire";
+import { discordChatLog, discordChatOutgoing, discordNotify, chatIncomingChannel, createCcWire, TIMING, } from "@gonzih/cc-wire";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
@@ -70,11 +70,12 @@ export function parseNotification(raw) {
 }
 /**
  * Write a message to the chat log in Redis.
+ * Uses discord-scoped keys (cca:discord:chat:log:{ns}, cca:discord:chat:outgoing:{ns}).
  * Fire-and-forget — errors are logged but not thrown.
  */
 export function writeChatLog(redis, namespace, msg) {
-    const logKey = chatLogKey(namespace);
-    const outKey = chatOutgoingChannel(namespace);
+    const logKey = discordChatLog(namespace);
+    const outKey = discordChatOutgoing(namespace);
     const payload = JSON.stringify(msg);
     redis.lpush(logKey, payload).catch((err) => {
         log("warn", "writeChatLog lpush failed:", err.message);
@@ -104,7 +105,7 @@ export function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId
  *
  * @param bot                     - CcDiscordBot instance (for sending messages)
  * @param notifyChannelId         - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace               - cc-agent namespace (used to build Redis channel names)
+ * @param namespace               - primary namespace (used to build Redis channel names)
  * @param redis                   - ioredis client in normal mode (will be duplicated for pub/sub)
  * @param handleUserMessage       - Optional callback to feed UI messages into the active Claude session
  * @param forwardNotification     - Optional callback to forward job notifications
@@ -112,6 +113,7 @@ export function resolveNotifyChannel(chatId, notifyChannelId, getActiveChannelId
  * @param reverseSnowflakeLookup  - Optional callback to resolve a chatId integer to a Discord channelId
  */
 export function startNotifier(bot, notifyChannelId, namespace, redis, handleUserMessage, forwardNotification, getActiveChannelId, reverseSnowflakeLookup) {
+    const wire = createCcWire(redis);
     // Per-namespace channelId registry — maps routed namespace → Discord channelId
     const routedChannelIds = new Map();
     // Track which namespaces we've already subscribed to (to avoid duplicate subscribe calls)
@@ -135,7 +137,7 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         if (subscribedNamespaces.has(ns))
             return;
         subscribedNamespaces.add(ns);
-        const notifyCh = notifyChannel(ns);
+        const notifyCh = discordNotify(ns);
         const incomingCh = chatIncomingChannel(ns);
         channelToNamespace.set(notifyCh, ns);
         channelToNamespace.set(incomingCh, ns);
@@ -161,17 +163,19 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
     }
     // Subscribe to the primary namespace immediately
     subscribeNamespace(namespace);
-    // chatOutgoingChannel("*") — meta-agent stdout lines for ALL namespaces
-    sub.psubscribe(chatOutgoingChannel("*"), (err) => {
+    // discordChatOutgoing("*") — meta-agent stdout lines for ALL discord namespaces
+    const outgoingPattern = discordChatOutgoing("*");
+    // Prefix to strip when extracting namespace from a matched channel name
+    const outgoingPrefix = discordChatOutgoing("");
+    sub.psubscribe(outgoingPattern, (err) => {
         if (err) {
-            log("error", `psubscribe ${chatOutgoingChannel("*")} failed:`, err.message);
+            log("error", `psubscribe ${outgoingPattern} failed:`, err.message);
         }
         else {
-            log("info", `psubscribed to ${chatOutgoingChannel("*")}`);
+            log("info", `psubscribed to ${outgoingPattern}`);
         }
     });
-    // 1.5s silence buffer for meta-agent streaming
-    const META_AGENT_FLUSH_DELAY_MS = 1500;
+    // Buffer for meta-agent streaming output — debounced before sending to Discord
     const metaAgentBuffers = new Map();
     function flushMetaAgentBuffer(ns, targetChannelId) {
         bot.stopMetaAgentTyping(targetChannelId);
@@ -190,7 +194,7 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
     }
     sub.on("pmessage", (pattern, channel, message) => {
         void pattern;
-        const ns = channel.slice(chatOutgoingChannel("").length);
+        const ns = channel.slice(outgoingPrefix.length);
         let parsed = null;
         try {
             parsed = JSON.parse(message);
@@ -203,8 +207,7 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         const content = parsed.content;
         if (!content)
             return;
-        // For the primary namespace: deliver to the primary Discord channel (DISCORD_NOTIFY_CHANNEL_ID
-        // or the last-active channel). Responses go to BOTH Telegram (via cc-tg) AND Discord.
+        // For the primary namespace: deliver to the primary Discord channel.
         // For other (routed) namespaces: only deliver to explicitly registered channelIds.
         const targetChannelId = routedChannelIds.get(ns) ??
             (ns === namespace ? (notifyChannelId ?? getActiveChannelId?.()) : undefined);
@@ -220,12 +223,12 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         buf.text += (buf.text ? "\n" : "") + content;
         if (buf.timer)
             clearTimeout(buf.timer);
-        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), META_AGENT_FLUSH_DELAY_MS);
+        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), TIMING.META_AGENT_FLUSH_DELAY_MS);
     });
-    // Poll notifyListKey(ns) LIST every 5 seconds — covers primary + all routed namespaces.
+    // Poll discordNotify(ns) LIST every 5 seconds — covers primary + all routed namespaces.
     const MAX_PER_CYCLE = 20;
     const pollOneNamespace = async (ns, targetChannelId) => {
-        const listKey = notifyListKey(ns);
+        const listKey = discordNotify(ns);
         const items = [];
         try {
             for (let i = 0; i < MAX_PER_CYCLE; i++) {
@@ -294,7 +297,7 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
         if (!ns)
             return;
         const isPrimary = ns === namespace;
-        const notifyCh = notifyChannel(ns);
+        const notifyCh = discordNotify(ns);
         const incomingCh = chatIncomingChannel(ns);
         if (channel === notifyCh) {
             const notification = parseNotification(message);
@@ -351,30 +354,31 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
                     role: "user",
                     content,
                     timestamp: originalTimestamp ?? new Date().toISOString(),
-                    chatId: 0, // no numeric chatId for Discord — stored by channelId string
+                    chatId: 0,
                 };
                 writeChatLog(redis, ns, inMsg);
-                // Check if a meta-agent is running; if so, route there instead
+                // Route to meta-agent input queue if this namespace has a registered session;
+                // otherwise fall through to handleUserMessage (local Claude session).
                 void (async () => {
                     let routedToMetaAgent = false;
-                    try {
-                        const statusRaw = await redis.get(metaAgentStatusKey(ns));
-                        if (statusRaw) {
-                            const status = JSON.parse(statusRaw);
-                            if (status.status === "running") {
-                                const entry = JSON.stringify({
+                    if (routedChannelIds.has(ns)) {
+                        try {
+                            const status = await wire.discord.getStatus(ns);
+                            if (status && (status.status === "running" || status.status === "idle")) {
+                                await wire.discord.enqueue(ns, {
                                     id: crypto.randomUUID(),
+                                    source: "ui",
+                                    role: "user",
                                     content,
                                     timestamp: new Date().toISOString(),
                                 });
-                                await redis.rpush(metaInputKey(ns), entry);
                                 log("info", `cca:chat:incoming: routed to meta-agent for namespace ${ns}`);
                                 routedToMetaAgent = true;
                             }
                         }
-                    }
-                    catch (err) {
-                        log("warn", `meta-agent status check failed (ns=${ns}):`, err.message);
+                        catch (err) {
+                            log("warn", `meta-agent status check failed (ns=${ns}):`, err.message);
+                        }
                     }
                     if (!routedToMetaAgent && handleUserMessage) {
                         handleUserMessage(targetChannelId, content);

package/dist/router.d.ts

@@ -1,30 +1,11 @@
 /**
  * Routing helpers: channel-creation intent detection and meta-agent routing.
- */
-import { Redis } from "ioredis";
-/** Callback type matching CcDiscordBot.callCcAgentTool */
-export type CallToolFn = (toolName: string, args?: Record<string, unknown>) => Promise<string | null>;
-/**
- * Ensure a meta-agent for the given namespace is running.
- *
- * Steps:
- *   1. Check Redis for readiness via two keys (see below) — return early if already ready.
- *   2. Verify the GitHub repo exists; create it (public) if not.
- *   3. Call the start_meta_agent MCP tool via callTool.
- *   4. Poll both Redis keys every 1s until ready or META_AGENT_TIMEOUT_MS expires.
  *
- * Two Redis keys are checked:
- *   cca:meta-agent:status:{namespace} — live-status key written by writeLiveStatus()
- *     (only populated after the first message is processed by messageMetaAgent)
- *   cca:meta:{namespace} — state key written by startMetaAgent() directly via saveState()
- *     (populated as soon as the workspace is created, with status:"idle")
- *
- * Bug context: start_meta_agent writes cca:meta:{namespace} but NOT cca:meta-agent:status:{namespace}.
- * Polling only the status key caused a 10s timeout on every cold start.
- *
- * Throws on failure (repo creation error, tool call failure, or timeout).
+ * v0.2.0: cc-discord owns meta-agent lifecycle directly.
+ * routeToMetaAgent now writes to the discord-scoped input key (cca:discord:meta:{ns}:input).
+ * ensureMetaAgent has been removed — use MetaAgentManager.ensureWorkspace instead.
  */
-export declare function ensureMetaAgent(namespace: string, repoUrl: string, callTool: CallToolFn, redis: Redis): Promise<void>;
+import { Redis } from "ioredis";
 /**
  * Detect a natural-language channel-creation request.
  * Matches:
@@ -40,8 +21,8 @@ export declare function parseChannelCreateIntent(text: string): {
 } | null;
 /**
  * Route a message to a running meta-agent via Redis RPUSH.
- * The cc-agent polls cca:meta:{namespace}:input every 3s (up to 3s delivery latency).
+ * cc-discord polls cca:discord:meta:{namespace}:input every 3s.
  *
- * No-op when strippedMessage is empty (user sent only the tag token).
+ * No-op when strippedMessage is empty.
  */
 export declare function routeToMetaAgent(namespace: string, strippedMessage: string, redis: Redis): Promise<void>;

package/dist/router.js

@@ -1,133 +1,11 @@
 /**
  * Routing helpers: channel-creation intent detection and meta-agent routing.
- */
-import { execSync } from "child_process";
-import { metaAgentStatusKey, metaKey, metaInputKey } from "@gonzih/cc-wire";
-/**
- * Ensure a meta-agent for the given namespace is running.
- *
- * Steps:
- *   1. Check Redis for readiness via two keys (see below) — return early if already ready.
- *   2. Verify the GitHub repo exists; create it (public) if not.
- *   3. Call the start_meta_agent MCP tool via callTool.
- *   4. Poll both Redis keys every 1s until ready or META_AGENT_TIMEOUT_MS expires.
  *
- * Two Redis keys are checked:
- *   cca:meta-agent:status:{namespace} — live-status key written by writeLiveStatus()
- *     (only populated after the first message is processed by messageMetaAgent)
- *   cca:meta:{namespace} — state key written by startMetaAgent() directly via saveState()
- *     (populated as soon as the workspace is created, with status:"idle")
- *
- * Bug context: start_meta_agent writes cca:meta:{namespace} but NOT cca:meta-agent:status:{namespace}.
- * Polling only the status key caused a 10s timeout on every cold start.
- *
- * Throws on failure (repo creation error, tool call failure, or timeout).
+ * v0.2.0: cc-discord owns meta-agent lifecycle directly.
+ * routeToMetaAgent now writes to the discord-scoped input key (cca:discord:meta:{ns}:input).
+ * ensureMetaAgent has been removed — use MetaAgentManager.ensureWorkspace instead.
  */
-export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
-    const timeoutMs = parseInt(process.env.META_AGENT_TIMEOUT_MS ?? "10000", 10);
-    const statusKey = metaAgentStatusKey(namespace);
-    // State key written by startMetaAgent() directly — the source of truth for workspace existence.
-    const stateKey = metaKey(namespace);
-    console.log(`[router] ensureMetaAgent namespace=${namespace}`);
-    // Fast path: check live-status key (written by messageMetaAgent after first message)
-    const statusRaw = await redis.get(statusKey);
-    if (statusRaw) {
-        try {
-            const status = JSON.parse(statusRaw);
-            if (status.status === "running" || status.status === "idle") {
-                console.log(`[router] meta-agent ${namespace} is already ready (status=${status.status})`);
-                return;
-            }
-        }
-        catch {
-            // Corrupt status value — fall through
-        }
-    }
-    // Fast path: also check state key (written by startMetaAgent, persists 30 days).
-    // Presence of this key means the workspace was already created — no need to re-run start_meta_agent.
-    const stateRaw = await redis.get(stateKey);
-    if (stateRaw) {
-        try {
-            const state = JSON.parse(stateRaw);
-            if (state.status === "idle" || state.status === "running") {
-                console.log(`[router] meta-agent ${namespace} workspace exists (state.status=${state.status})`);
-                return;
-            }
-        }
-        catch {
-            // Corrupt state — fall through and re-initialize
-        }
-    }
-    // Derive "org/repo" from the full URL for gh CLI calls
-    const orgRepo = repoUrl.replace(/^https:\/\/github\.com\//, "");
-    // Verify / create the GitHub repo
-    try {
-        execSync(`gh repo view ${orgRepo}`, { stdio: "ignore" });
-    }
-    catch {
-        // Repo not found — create it
-        try {
-            execSync(`gh repo create ${orgRepo} --public --description "Meta-agent workspace for ${namespace}"`, { stdio: "pipe" });
-            console.log(`[router] created repo ${orgRepo} for namespace=${namespace}`);
-        }
-        catch (createErr) {
-            throw new Error(`Failed to create repo ${orgRepo}: ${createErr.message}`);
-        }
-    }
-    // Start the meta-agent via MCP (clones workspace if needed, writes cca:meta:{namespace})
-    const result = await callTool("start_meta_agent", { namespace, repo_url: repoUrl });
-    if (result === null) {
-        throw new Error(`start_meta_agent returned null — tool may not be available in cc-agent`);
-    }
-    // Check for explicit failure payload (e.g. git clone error)
-    try {
-        const parsed = JSON.parse(result);
-        if (parsed.ok === false) {
-            throw new Error(`start_meta_agent failed: ${parsed.error ?? "unknown error"}`);
-        }
-    }
-    catch (jsonErr) {
-        if (!(jsonErr instanceof SyntaxError))
-            throw jsonErr;
-        // Non-JSON result (e.g. plain "ok") — not an error, continue to poll
-    }
-    // Poll until ready. Check both keys:
-    //   - statusKey: written by writeLiveStatus() during messageMetaAgent (may not exist yet on cold start)
-    //   - stateKey:  written by startMetaAgent() above — will appear within 1s of the tool call returning
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const raw = await redis.get(statusKey);
-        if (raw) {
-            try {
-                const s = JSON.parse(raw);
-                console.log(`[router] waiting for meta-agent ${namespace} — status key: ${s.status}`);
-                if (s.status === "running" || s.status === "idle")
-                    return;
-            }
-            catch {
-                // ignore parse errors, keep polling
-            }
-        }
-        // Also check state key — startMetaAgent writes this synchronously before responding
-        const state = await redis.get(stateKey);
-        if (state) {
-            try {
-                const s = JSON.parse(state);
-                console.log(`[router] waiting for meta-agent ${namespace} — state key: ${s.status}`);
-                if (s.status === "idle" || s.status === "running")
-                    return;
-            }
-            catch {
-                // ignore parse errors, keep polling
-            }
-        }
-        else {
-            console.log(`[router] waiting for meta-agent ${namespace} — neither key present yet`);
-        }
-    }
-    throw new Error(`Meta-agent for ${namespace} did not become ready within ${timeoutMs}ms`);
-}
+import { discordMetaInputKey } from "@gonzih/cc-wire";
 /**
  * Detect a natural-language channel-creation request.
  * Matches:
@@ -147,9 +25,9 @@ export function parseChannelCreateIntent(text) {
 }
 /**
  * Route a message to a running meta-agent via Redis RPUSH.
- * The cc-agent polls cca:meta:{namespace}:input every 3s (up to 3s delivery latency).
+ * cc-discord polls cca:discord:meta:{namespace}:input every 3s.
  *
- * No-op when strippedMessage is empty (user sent only the tag token).
+ * No-op when strippedMessage is empty.
  */
 export async function routeToMetaAgent(namespace, strippedMessage, redis) {
     if (!strippedMessage)
@@ -159,7 +37,6 @@ export async function routeToMetaAgent(namespace, strippedMessage, redis) {
         content: strippedMessage,
         timestamp: new Date().toISOString(),
     });
-    // FIFO — cc-agent reads via LPOP
-    await redis.rpush(metaInputKey(namespace), entry);
+    await redis.rpush(discordMetaInputKey(namespace), entry);
     console.log(`[router] routed message to meta-agent namespace=${namespace}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.1.17",
+  "version": "0.2.0",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "dist/"
   ],
   "dependencies": {
-    "@gonzih/cc-wire": "^0.1.6",
+    "@gonzih/cc-wire": "^0.3.0",
     "discord.js": "^14.0.0",
     "ioredis": "^5.0.0"
   },