@gonzih/cc-discord 0.2.48 → 0.2.50

package/dist/meta-agent-manager.js

@@ -18,6 +18,11 @@ import { join } from "path";
 import { homedir } from "os";
 import { CC_DISCORD_WORKSPACE_ROOT, TIMING, DISCORD_INSTANCE_KEY, discordMetaInputKey, discordChatOutgoing, metaStreamChannel as ccWireMetaStreamChannel, metaLogKey as ccWireMetaLogKey, } from "@gonzih/cc-wire";
 const WORKSPACE_ROOT = join(homedir(), CC_DISCORD_WORKSPACE_ROOT);
+const CHAT_SOURCE = "claude";
+function agentDriver() {
+    const raw = (process.env.CC_DISCORD_AGENT_DRIVER ?? process.env.AGENT_DRIVER ?? "claude").toLowerCase();
+    return raw === "codex" ? "codex" : "claude";
+}
 /**
  * Returns the path to the workspace for the given namespace.
  * Creates the parent root directory if needed.
@@ -52,13 +57,18 @@ export async function ensureWorkspace(ns, repoUrl) {
  *
  * 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
+ *   2. Built-in template: gitkb MCP plus ATC shell environment
  *
  * Variables substituted in the template: {namespace}, {workspacePath}, {token},
  * {npmCache}, {trustedOwners}, {path}.
  */
 export function injectMcp(ns, wsPath, token) {
     const mcpPath = join(wsPath, ".mcp.json");
+    const codexDir = join(wsPath, ".codex");
+    const codexConfigPath = join(codexDir, "config.toml");
+    const agentsPath = join(wsPath, "AGENTS.md");
+    const atcDir = join(wsPath, ".atc");
+    const atcConfigPath = join(atcDir, "config.toml");
     if (process.env.CC_DISCORD_MCP_JSON) {
         const rendered = process.env.CC_DISCORD_MCP_JSON
             .replace(/\{namespace\}/g, ns)
@@ -66,34 +76,75 @@ export function injectMcp(ns, wsPath, token) {
             .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 ?? "gonzih,ecoclaw,simorgh-app";
-    const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
-    const config = {
-        mcpServers: {
-            "gitkb": {
-                command: "/opt/homebrew/bin/git-kb",
-                args: ["mcp"],
-            },
-            "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,
+    else {
+        const npmCache = process.env.npm_config_cache ?? `${homedir()}/.npm`;
+        const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+        const config = {
+            mcpServers: {
+                "gitkb": {
+                    command: "/opt/homebrew/bin/git-kb",
+                    args: ["mcp"],
+                    env: {
+                        GITKB_ROOT: wsPath,
+                        ATC_ROOT: process.env.ATC_ROOT ?? `${homedir()}/.local/share/atc`,
+                        DISPATCH_KB_ROOT: wsPath,
+                        DISPATCH_META_ROOT: process.env.DISPATCH_META_ROOT ?? wsPath,
+                        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}`);
+        };
+        writeFileSync(mcpPath, JSON.stringify(config, null, 2), "utf8");
+        console.log(`[meta-agent-manager] injected MCP config for namespace=${ns}`);
+    }
+    const npmCache = process.env.npm_config_cache ?? `${homedir()}/.npm`;
+    const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    mkdirSync(codexDir, { recursive: true });
+    mkdirSync(atcDir, { recursive: true });
+    writeFileSync(codexConfigPath, [
+        "[mcp_servers.gitkb]",
+        'command = "/opt/homebrew/bin/git-kb"',
+        'args = ["mcp"]',
+        "",
+        "[mcp_servers.gitkb.env]",
+        `GITKB_ROOT = ${JSON.stringify(wsPath)}`,
+        `ATC_ROOT = ${JSON.stringify(process.env.ATC_ROOT ?? `${homedir()}/.local/share/atc`)}`,
+        `DISPATCH_KB_ROOT = ${JSON.stringify(wsPath)}`,
+        `DISPATCH_META_ROOT = ${JSON.stringify(process.env.DISPATCH_META_ROOT ?? wsPath)}`,
+        `PATH = ${JSON.stringify(systemPath)}`,
+        `npm_config_cache = ${JSON.stringify(npmCache)}`,
+        "",
+    ].join("\n"), "utf8");
+    writeFileSync(atcConfigPath, [
+        "[dispatch]",
+        "sandbox = false",
+        "project_env = true",
+        `max_turns = ${Number(process.env.ATC_MAX_TURNS ?? 10000)}`,
+        `max_budget_usd = ${Number(process.env.ATC_MAX_BUDGET_USD ?? 250)}`,
+        `max_retries = ${Number(process.env.ATC_MAX_RETRIES ?? 1)}`,
+        "",
+    ].join("\n"), "utf8");
+    if (!existsSync(agentsPath)) {
+        writeFileSync(agentsPath, [
+            `# ${ns} Agent Workspace`,
+            "",
+            "- This workspace is managed by cc-discord.",
+            "- Use gitkb for project memory.",
+            "- Use ATC for spawned or delegated agent work; ATC is a private local/cloud system and must not be vendored, published, or documented as public API.",
+            "- ATC command patterns:",
+            "  - Implement a task: `GITKB_ROOT=$PWD atc run task <slug>`",
+            "  - Research a task: `GITKB_ROOT=$PWD atc run research task <slug>`",
+            "  - Review a PR: `GITKB_ROOT=$PWD atc run pr-review --param pr=<url>`",
+            "  - Monitor work: `atc status --flat`, `atc logs <slug-or-id>`, `atc watch --id <dispatch-id>`",
+            "- Dry-run before dispatch: run `atc run <args> --dry-run`, inspect resolver/directive/worktree/repo, adjust the command, and dry-run again until the output matches intent.",
+            "- Never dispatch when the dry-run resolves as raw `prompt` unless raw-prompt dispatch is explicitly intended.",
+            "- Keep changes scoped to the registered repository for this Discord namespace.",
+            "",
+        ].join("\n"), "utf8");
+    }
+    console.log(`[meta-agent-manager] injected Codex config for namespace=${ns}`);
 }
 /**
  * Resolve claude binary — same logic as claude.ts resolveClaude.
@@ -121,6 +172,27 @@ function resolveClaude() {
     }
     return "claude";
 }
+function resolveCodex() {
+    if (process.env.CODEX_BIN)
+        return process.env.CODEX_BIN;
+    const dirs = (process.env.PATH ?? "").split(":");
+    for (const dir of dirs) {
+        const c = `${dir}/codex`;
+        if (existsSync(c))
+            return c;
+    }
+    const fallbacks = [
+        `${homedir()}/.npm-global/bin/codex`,
+        "/opt/homebrew/bin/codex",
+        "/usr/local/bin/codex",
+        "/usr/bin/codex",
+    ];
+    for (const p of fallbacks) {
+        if (existsSync(p))
+            return p;
+    }
+    return "codex";
+}
 /**
  * Redis keys for meta-agent stdout streaming.
  * cca:meta:{ns}:stream — pub/sub channel (live streaming)
@@ -134,6 +206,8 @@ export const metaLogKey = ccWireMetaLogKey;
  */
 function buildEnv(token) {
     const env = { ...process.env };
+    if (!token)
+        return env;
     if (token.startsWith("sk-ant-api")) {
         env.ANTHROPIC_API_KEY = token;
         delete env.CLAUDE_CODE_OAUTH_TOKEN;
@@ -144,6 +218,276 @@ function buildEnv(token) {
     }
     return env;
 }
+function codexArgs(message, sessionId) {
+    const extra = (process.env.CC_DISCORD_CODEX_ARGS ?? "--dangerously-bypass-approvals-and-sandbox")
+        .split(/\s+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (sessionId) {
+        return ["exec", "resume", "--json", "--skip-git-repo-check", ...extra, sessionId, message];
+    }
+    return ["exec", "--json", "--skip-git-repo-check", ...extra, message];
+}
+function codexAppServerArgs() {
+    const extra = (process.env.CC_DISCORD_CODEX_SERVER_ARGS ?? "")
+        .split(/\s+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return ["app-server", "--stdio", ...extra];
+}
+function codexThreadParams(wsPath) {
+    return {
+        cwd: wsPath,
+        approvalPolicy: process.env.CC_DISCORD_CODEX_APPROVAL_POLICY ?? "never",
+        sandbox: process.env.CC_DISCORD_CODEX_SANDBOX ?? "danger-full-access",
+    };
+}
+function codexTurnParams(threadId, message, wsPath) {
+    return {
+        threadId,
+        cwd: wsPath,
+        approvalPolicy: process.env.CC_DISCORD_CODEX_APPROVAL_POLICY ?? "never",
+        sandboxPolicy: { type: "dangerFullAccess" },
+        input: [{ type: "text", text: message, text_elements: [] }],
+    };
+}
+function publishDiscordEvent(wire, ns, driver, event, content = "") {
+    wire._redis.publish(discordChatOutgoing(ns), JSON.stringify({
+        id: crypto.randomUUID(),
+        source: driver,
+        role: "assistant",
+        content,
+        event,
+        timestamp: new Date().toISOString(),
+        chatId: 0,
+    })).catch(() => { });
+}
+function publishAssistantText(wire, ns, driver, content, logLabel = "publishOutgoing") {
+    const msg = {
+        id: crypto.randomUUID(),
+        source: driver,
+        role: "assistant",
+        content,
+        timestamp: new Date().toISOString(),
+        chatId: 0,
+    };
+    if (driver === "codex") {
+        wire._redis.publish(discordChatOutgoing(ns), JSON.stringify(msg)).catch((err) => {
+            console.warn(`[meta-agent-manager] ${logLabel} failed (ns=${ns}):`, err.message);
+        });
+        return;
+    }
+    wire.discord.publishOutgoing(ns, { ...msg, source: CHAT_SOURCE }).catch((err) => {
+        console.warn(`[meta-agent-manager] ${logLabel} failed (ns=${ns}):`, err.message);
+    });
+}
+function extractCodexItemText(item) {
+    if (!item)
+        return "";
+    if (typeof item.text === "string")
+        return item.text;
+    const content = item.content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((part) => {
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    }).join("");
+}
+const codexDeltaItemIds = new Set();
+function forwardCodexAppServerMessage(ns, wire, msg) {
+    const eventJson = JSON.stringify(msg);
+    const rawRedis = wire._redis;
+    const streamCh = metaStreamChannel(ns);
+    const logKey = metaLogKey(ns);
+    rawRedis.publish(streamCh, eventJson).catch((err) => {
+        console.warn(`[meta-agent-manager] codex 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] codex log lpush failed (ns=${ns}):`, err.message);
+    });
+    const method = typeof msg.method === "string" ? msg.method : "";
+    const params = (msg.params && typeof msg.params === "object") ? msg.params : {};
+    if (method === "item/agentMessage/delta" && typeof params.delta === "string" && params.delta) {
+        if (typeof params.itemId === "string")
+            codexDeltaItemIds.add(`${ns}:${params.itemId}`);
+        publishAssistantText(wire, ns, "codex", params.delta, "codex delta publishOutgoing");
+        return;
+    }
+    if (method === "item/started") {
+        const item = params.item;
+        const itemType = typeof item?.type === "string" ? item.type : "";
+        if (itemType === "commandExecution" || itemType === "mcpToolCall" || itemType === "dynamicToolCall") {
+            const label = typeof item?.command === "string"
+                ? item.command
+                : typeof item?.tool === "string"
+                    ? item.tool
+                    : itemType;
+            publishDiscordEvent(wire, ns, "codex", "tool_start", label);
+        }
+        return;
+    }
+    if (method === "item/completed") {
+        const item = params.item;
+        const itemType = typeof item?.type === "string" ? item.type : "";
+        if (itemType === "agentMessage") {
+            const itemId = typeof item?.id === "string" ? item.id : "";
+            if (itemId && codexDeltaItemIds.has(`${ns}:${itemId}`)) {
+                codexDeltaItemIds.delete(`${ns}:${itemId}`);
+                return;
+            }
+            const text = extractCodexItemText(item);
+            if (text) {
+                publishAssistantText(wire, ns, "codex", text, "codex item publishOutgoing");
+            }
+        }
+        else if (itemType === "commandExecution" || itemType === "mcpToolCall" || itemType === "dynamicToolCall") {
+            publishDiscordEvent(wire, ns, "codex", "tool_end");
+        }
+        return;
+    }
+    if (method === "turn/completed") {
+        publishDiscordEvent(wire, ns, "codex", "done");
+        return;
+    }
+    if (method === "error" || msg.error) {
+        const err = (msg.error && typeof msg.error === "object") ? msg.error : params;
+        const message = typeof err.message === "string" ? err.message : JSON.stringify(err);
+        publishAssistantText(wire, ns, "codex", `⚠️ Error: ${message}`, "codex error publishOutgoing");
+    }
+}
+function spawnCodexAppServerSession(ns, token, wire, onExit) {
+    const wsPath = workspacePath(ns);
+    const proc = spawn(resolveCodex(), codexAppServerArgs(), {
+        cwd: wsPath,
+        env: buildEnv(token),
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    proc.stdin.setDefaultEncoding("utf8");
+    const pending = new Map();
+    let nextId = 1;
+    let lineBuffer = "";
+    const session = {
+        proc,
+        ns,
+        wsPath,
+        running: false,
+        queue: [],
+        ready: Promise.resolve(),
+        sendRequest(method, params) {
+            const id = nextId++;
+            const message = { method, id, params };
+            return new Promise((resolve, reject) => {
+                pending.set(id, { resolve, reject });
+                proc.stdin.write(`${JSON.stringify(message)}\n`, (err) => {
+                    if (err) {
+                        pending.delete(id);
+                        reject(err);
+                    }
+                });
+            });
+        },
+        sendNotification(method, params) {
+            proc.stdin.write(`${JSON.stringify({ method, params })}\n`);
+        },
+        stop() {
+            for (const [, waiter] of pending)
+                waiter.reject(new Error("Codex app-server stopped"));
+            pending.clear();
+            try {
+                proc.stdin.end();
+                proc.kill("SIGTERM");
+            }
+            catch {
+                // ignore shutdown errors
+            }
+        },
+    };
+    function handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            msg = { method: "text", params: { text: trimmed } };
+        }
+        if (typeof msg.id === "number") {
+            const waiter = pending.get(msg.id);
+            if (waiter) {
+                pending.delete(msg.id);
+                if (msg.error) {
+                    const err = msg.error;
+                    waiter.reject(new Error(err.message ?? JSON.stringify(msg.error)));
+                }
+                else {
+                    waiter.resolve(msg);
+                }
+            }
+        }
+        const method = typeof msg.method === "string" ? msg.method : "";
+        if (method === "turn/started") {
+            const params = (msg.params && typeof msg.params === "object") ? msg.params : {};
+            const turn = (params.turn && typeof params.turn === "object") ? params.turn : {};
+            if (typeof turn.id === "string")
+                session.activeTurnId = turn.id;
+        }
+        else if (method === "turn/completed") {
+            session.activeTurnId = undefined;
+        }
+        forwardCodexAppServerMessage(ns, wire, msg);
+    }
+    proc.stdout.on("data", (chunk) => {
+        lineBuffer += chunk.toString();
+        const lines = lineBuffer.split("\n");
+        lineBuffer = lines.pop() ?? "";
+        for (const line of lines)
+            handleLine(line);
+    });
+    proc.stderr.on("data", (chunk) => {
+        const text = chunk.toString().trim();
+        if (text)
+            console.log(`[meta-agent-manager:${ns}:codex-stderr] ${text}`);
+    });
+    proc.on("exit", (code) => {
+        if (lineBuffer.trim())
+            handleLine(lineBuffer);
+        for (const [, waiter] of pending)
+            waiter.reject(new Error(`Codex app-server exited with code ${code}`));
+        pending.clear();
+        console.log(`[meta-agent-manager] codex app-server exited (ns=${ns}, code=${code})`);
+        onExit();
+    });
+    proc.on("error", (err) => {
+        for (const [, waiter] of pending)
+            waiter.reject(err);
+        pending.clear();
+        console.error(`[meta-agent-manager] codex app-server spawn error (ns=${ns}):`, err.message);
+        onExit();
+    });
+    session.ready = (async () => {
+        await session.sendRequest("initialize", {
+            clientInfo: { name: "cc-discord", title: "cc-discord", version: "0.1.0" },
+            capabilities: { experimentalApi: true, requestAttestation: false },
+        });
+        session.sendNotification("initialized", {});
+        const threadResponse = await session.sendRequest("thread/start", codexThreadParams(wsPath));
+        const result = (threadResponse.result && typeof threadResponse.result === "object")
+            ? threadResponse.result
+            : {};
+        const thread = (result.thread && typeof result.thread === "object") ? result.thread : {};
+        if (typeof thread.id !== "string")
+            throw new Error("Codex app-server did not return a thread id");
+        session.threadId = thread.id;
+    })();
+    return session;
+}
 /**
  * Wire stdout from a claude subprocess into Redis.
  * Parses JSONL lines from stream-json format, publishes to:
@@ -151,12 +495,10 @@ function buildEnv(token) {
  *   LPUSH   cca:meta:{ns}:log  (capped at 2000)
  * Also dispatches assistant/result text to wire.discord.publishOutgoing.
  */
-function wireStdoutToRedis(proc, ns, wire) {
+function wireStdoutToRedis(proc, ns, wire, driver = "claude", onParsedEvent) {
     const rawRedis = wire._redis;
     const streamCh = metaStreamChannel(ns);
     const logKey = metaLogKey(ns);
-    // Deduplicate rate_limit_event: Claude emits multiple per turn; only notify once per session.
-    let rateLimitNotified = false;
     const forwardEventToRedis = (eventJson) => {
         rawRedis.publish(streamCh, eventJson).catch((err) => {
             console.warn(`[meta-agent-manager] stream publish failed (ns=${ns}):`, err.message);
@@ -174,6 +516,7 @@ function wireStdoutToRedis(proc, ns, wire) {
         let structuredEvent;
         try {
             const parsed = JSON.parse(trimmed);
+            onParsedEvent?.(parsed);
             const type = parsed.type;
             if (type === "assistant") {
                 const content = parsed.message;
@@ -181,17 +524,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                 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);
-                    });
+                    publishAssistantText(wire, ns, driver, text);
                 }
             }
             else if (type === "tool_use") {
@@ -203,7 +536,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                 };
                 // Ephemeral signal: notifier shows tool activity overlay in the live message
                 rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
-                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    id: crypto.randomUUID(), source: driver, role: "assistant",
                     content: toolName, event: "tool_start", timestamp: new Date().toISOString(), chatId: 0,
                 })).catch(() => { });
             }
@@ -214,7 +547,7 @@ function wireStdoutToRedis(proc, ns, wire) {
                 };
                 // Ephemeral signal: tool finished, notifier can restart finalize timer
                 rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
-                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    id: crypto.randomUUID(), source: driver, role: "assistant",
                     content: "", event: "tool_end", timestamp: new Date().toISOString(), chatId: 0,
                 })).catch(() => { });
             }
@@ -227,55 +560,54 @@ function wireStdoutToRedis(proc, ns, wire) {
                 };
                 if (parsed.is_error && resultText) {
                     // Error case: assistant event may not carry the error message — publish it directly
-                    const errMsg = {
-                        id: crypto.randomUUID(),
-                        source: "claude",
-                        role: "assistant",
-                        content: `⚠️ Error: ${resultText}`,
-                        timestamp: new Date().toISOString(),
-                        chatId: 0,
-                    };
-                    wire.discord.publishOutgoing(ns, errMsg).catch(() => { });
+                    publishAssistantText(wire, ns, driver, `⚠️ Error: ${resultText}`);
                 }
                 // Signal turn completion — text was already published via the assistant event above.
                 // Do NOT re-publish resultText here: that would double-deliver the same content.
                 rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
-                    id: crypto.randomUUID(), source: "claude", role: "assistant",
+                    id: crypto.randomUUID(), source: driver, role: "assistant",
                     content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
                 })).catch(() => { });
             }
-            else if (type === "rate_limit_event") {
-                const rl = parsed.rate_limit_info;
+            else if (driver === "codex" && type === "item.completed") {
+                const item = parsed.item;
+                const itemType = item?.type;
+                const text = typeof item?.text === "string" ? item.text : "";
                 structuredEvent = parsed;
-                // Throttled: five-hour window exhausted and no overage credits.
-                // Claude emits multiple rate_limit_events per turn — only act on the first.
-                if (rl?.overageStatus === "rejected" && !rateLimitNotified) {
-                    rateLimitNotified = true;
-                    const resetsAt = rl.resetsAt ? new Date(rl.resetsAt * 1000).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", timeZoneName: "short" }) : "soon";
-                    const alertContent = `⏳ Rate limited — five-hour window exhausted. Resets at **${resetsAt}**. Session paused; send any message after reset to resume.`;
-                    // 1. Close the current turn first — finalizes any real response text already in the live state.
-                    //    If this is a pure rate-limit turn (no preceding text), done is a no-op in the notifier.
+                if (itemType === "agent_message" && text) {
+                    publishAssistantText(wire, ns, "codex", text);
+                }
+                else if (itemType === "command_execution" || itemType === "mcp_tool_call") {
                     rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
-                        id: crypto.randomUUID(), source: "claude", role: "assistant",
-                        content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                        id: crypto.randomUUID(), source: driver, role: "assistant",
+                        content: "", event: "tool_end", timestamp: new Date().toISOString(), chatId: 0,
                     })).catch(() => { });
-                    // 2. Send alert tagged as "rate_limit" so the notifier delivers it as a standalone message,
-                    //    not accumulated into whatever text the current live state already holds.
+                }
+            }
+            else if (driver === "codex" && type === "item.started") {
+                const item = parsed.item;
+                const itemType = item?.type;
+                structuredEvent = parsed;
+                if (itemType === "command_execution" || itemType === "mcp_tool_call") {
+                    const label = typeof item?.command === "string" ? item.command : (itemType ?? "tool");
                     rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
-                        id: crypto.randomUUID(), source: "claude", role: "assistant",
-                        content: alertContent, event: "rate_limit",
-                        timestamp: new Date().toISOString(), chatId: 0,
+                        id: crypto.randomUUID(), source: driver, role: "assistant",
+                        content: label, event: "tool_start", timestamp: new Date().toISOString(), chatId: 0,
                     })).catch(() => { });
-                    // Kill the process — API calls will hang until reset anyway
-                    setTimeout(() => {
-                        try {
-                            proc.stdin.end();
-                            proc.kill("SIGTERM");
-                        }
-                        catch { /* ignore */ }
-                    }, 500);
                 }
             }
+            else if (driver === "codex" && (type === "turn.completed" || type === "turn.failed")) {
+                structuredEvent = parsed;
+                rawRedis.publish(discordChatOutgoing(ns), JSON.stringify({
+                    id: crypto.randomUUID(), source: driver, role: "assistant",
+                    content: "", event: "done", timestamp: new Date().toISOString(), chatId: 0,
+                })).catch(() => { });
+            }
+            else if (driver === "codex" && type === "error") {
+                const message = typeof parsed.message === "string" ? parsed.message : JSON.stringify(parsed);
+                structuredEvent = parsed;
+                publishAssistantText(wire, ns, "codex", `⚠️ Error: ${message}`);
+            }
             else {
                 structuredEvent = parsed;
             }
@@ -317,8 +649,26 @@ function wireStdoutToRedis(proc, ns, wire) {
 export function spawnSession(ns, message, token, wire) {
     return new Promise((resolve, reject) => {
         const wsPath = workspacePath(ns);
-        const claudeBin = resolveClaude();
         const env = buildEnv(token);
+        const driver = agentDriver();
+        if (driver === "codex") {
+            const proc = spawn(resolveCodex(), codexArgs(message), {
+                cwd: wsPath,
+                env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            wireStdoutToRedis(proc, ns, wire, "codex");
+            proc.on("exit", (code) => {
+                console.log(`[meta-agent-manager] codex session exited (ns=${ns}, code=${code})`);
+                resolve();
+            });
+            proc.on("error", (err) => {
+                console.error(`[meta-agent-manager] codex spawn error (ns=${ns}):`, err.message);
+                reject(err);
+            });
+            return;
+        }
+        const claudeBin = resolveClaude();
         const proc = spawn(claudeBin, [
             "--continue",
             "-p", message,
@@ -397,6 +747,8 @@ export function createMetaAgentManager() {
     let watchdogInterval = null;
     /** One persistent ChildProcess per namespace. */
     const sessions = new Map();
+    /** One persistent Codex app-server process per namespace. */
+    const codexSessions = new Map();
     /** Namespaces currently being set up (workspace clone / first spawn). */
     const startingUp = new Set();
     /** Wire reference needed for watchdog notifications. Set in startPolling. */
@@ -488,6 +840,91 @@ export function createMetaAgentManager() {
             writeToStdin(ns, content);
         }
     }
+    async function popQueueMessage(ns, wire) {
+        const inputKey = discordMetaInputKey(ns);
+        let raw;
+        try {
+            raw = await wire._redis.lpop(inputKey);
+        }
+        catch {
+            return null;
+        }
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw).content ?? raw;
+        }
+        catch {
+            return raw;
+        }
+    }
+    async function ensureCodexSession(ns, repoUrl, token, wire) {
+        const existing = codexSessions.get(ns);
+        if (existing) {
+            await existing.ready;
+            return existing;
+        }
+        const wsPath = workspacePath(ns);
+        await ensureWorkspace(ns, repoUrl);
+        injectMcp(ns, wsPath, token);
+        const session = spawnCodexAppServerSession(ns, token, wire, () => {
+            codexSessions.delete(ns);
+            console.log(`[meta-agent-manager] codex session removed from map (ns=${ns})`);
+        });
+        codexSessions.set(ns, session);
+        await session.ready;
+        return session;
+    }
+    async function runCodexTurn(ns, repoUrl, token, wire, message) {
+        const session = await ensureCodexSession(ns, repoUrl, token, wire);
+        if (message.trim() === "/compact") {
+            await session.sendRequest("thread/compact/start", { threadId: session.threadId });
+            return;
+        }
+        if (!session.threadId)
+            throw new Error("Codex app-server session is missing thread id");
+        const response = await session.sendRequest("turn/start", codexTurnParams(session.threadId, message, session.wsPath));
+        const result = (response.result && typeof response.result === "object") ? response.result : {};
+        const turn = (result.turn && typeof result.turn === "object") ? result.turn : {};
+        if (typeof turn.id === "string")
+            session.activeTurnId = turn.id;
+    }
+    async function drainCodexQueue(ns, repoUrl, token, wire) {
+        const session = await ensureCodexSession(ns, repoUrl, token, wire);
+        if (session.running)
+            return;
+        session.running = true;
+        try {
+            for (;;) {
+                const message = await popQueueMessage(ns, wire);
+                if (message == null)
+                    break;
+                if (session.activeTurnId && session.threadId) {
+                    await session.sendRequest("turn/steer", {
+                        threadId: session.threadId,
+                        expectedTurnId: session.activeTurnId,
+                        input: [{ type: "text", text: message, text_elements: [] }],
+                    });
+                }
+                else {
+                    await runCodexTurn(ns, repoUrl, token, wire, message);
+                }
+            }
+            await wire.discord.setStatus(ns, {
+                namespace: ns,
+                status: "running",
+                isTyping: false,
+                turnCount: 0,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[meta-agent-manager] drainCodexQueue failed (ns=${ns}):`, err.message);
+        }
+        finally {
+            session.running = false;
+        }
+    }
     /**
      * Ensure a persistent session exists for ns.
      * If one already exists, returns immediately.
@@ -577,6 +1014,28 @@ export function createMetaAgentManager() {
                         }).catch(() => { });
                     }
                     // If session exists, drain any queued messages
+                    if (agentDriver() === "codex") {
+                        const inputKey = discordMetaInputKey(ns);
+                        wire._redis.llen(inputKey).then(async (queueLen) => {
+                            if (queueLen === 0)
+                                return;
+                            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
+                                    ?? "";
+                            }
+                            await drainCodexQueue(ns, repoUrl, token, wire);
+                        }).catch((err) => {
+                            console.warn(`[meta-agent-manager] codex llen error (ns=${ns}):`, err.message);
+                        });
+                        continue;
+                    }
+                    // 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);
@@ -634,8 +1093,22 @@ export function createMetaAgentManager() {
                 sessions.delete(ns);
                 console.log(`[meta-agent-manager] killed session on stop (ns=${ns})`);
             }
+            for (const [ns, session] of codexSessions) {
+                session.stop();
+                codexSessions.delete(ns);
+                console.log(`[meta-agent-manager] killed codex session on stop (ns=${ns})`);
+            }
+            codexSessions.clear();
         },
         killSession(ns) {
+            if (agentDriver() === "codex") {
+                const session = codexSessions.get(ns);
+                if (session)
+                    session.stop();
+                codexSessions.delete(ns);
+                console.log(`[meta-agent-manager] cleared codex session state (ns=${ns})`);
+                return;
+            }
             const session = sessions.get(ns);
             if (!session)
                 return;
@@ -650,12 +1123,25 @@ export function createMetaAgentManager() {
             console.log(`[meta-agent-manager] killed session (ns=${ns})`);
         },
         sendToSession(ns, line) {
+            if (agentDriver() === "codex") {
+                if (!wireRef)
+                    return;
+                wireRef._redis.rpush(discordMetaInputKey(ns), JSON.stringify({
+                    id: crypto.randomUUID(),
+                    content: line,
+                    timestamp: new Date().toISOString(),
+                    source: "cc-discord",
+                })).catch((err) => {
+                    console.warn(`[meta-agent-manager] codex sendToSession enqueue failed (ns=${ns}):`, err.message);
+                });
+                return;
+            }
             writeToStdin(ns, line);
         },
     };
 }
 /**
- * Migrate the old cc-agent meta input key to the new cc-discord key.
+ * Migrate the old meta input key to the new cc-discord key.
  * Old: cca:meta:{ns}:input → New: cca:discord:meta:{ns}:input
  *
  * Called once on startup.