@inetafrica/open-claudia 1.14.9 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v1.16.0
+- OpenAI Codex backend support: `/codex` to switch, `/backend` picker now has 3 options
+- Auto-detects `codex` binary via `which codex` at startup; opt-in via `CODEX_PATH` in .env
+- Codex sessions persist (`codexSessionId`) across restarts and resume via `codex exec resume <id>`
+- Per-backend session IDs maintained independently — switch freely without losing context
+- Stream parser handles Codex JSONL events: `thread.started`, `item.started`, `item.completed`, `turn.completed` (with usage)
+- Plan mode on Codex maps to `--sandbox read-only`; outside plan mode uses `--dangerously-bypass-approvals-and-sandbox` (bot is the sandbox)
+- `/model` picker shows Codex models (gpt-5, gpt-5-codex, o3, o4-mini) when on Codex
+- Effort/budget gracefully reject on Codex (not exposed as CLI flags); Claude auth preflight scoped strictly to the Claude backend
+- Codex auth errors in stderr produce an actionable "run `codex login`" recovery message
+
 ## v1.14.9
 - Fix `/upgrade`: `latest` was const-scoped to the version-check try
   block, so the install step ran with `latest` undefined and threw

package/README.md

@@ -1,12 +1,12 @@
 # Open Claudia
 
-Your always-on AI coding assistant — Claude Code and Cursor Agent via Telegram.
+Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram.
 
 Send text, voice notes, screenshots, and files from your phone. Your chosen AI agent works on your projects and reports back.
 
 ## Features
 
-- **Multi-backend** — switch between Claude Code and Cursor Agent on the fly (`/cursor`, `/claude`)
+- **Multi-backend** — switch between Claude Code, Cursor Agent, and OpenAI Codex on the fly (`/claude`, `/cursor`, `/codex`)
 - **Multi-project sessions** — switch between workspace projects
 - **Per-project conversation history** — auto-resumes last conversation, switch with `/sessions`
 - **Separate session persistence** — Claude and Cursor each maintain their own conversation state
@@ -55,6 +55,14 @@ agent login               # Opens browser to authenticate
 agent status              # Verify: should show your email and plan
 ```
 
+**OpenAI Codex** (optional — enables `/codex` backend):
+
+```bash
+npm install -g @openai/codex
+codex login               # Opens browser to authenticate
+codex --version           # Verify it works
+```
+
 > **Important**: Claude Code can use macOS Keychain when you log in interactively, but a launchd/background bot may not be able to read that Keychain session. Open Claudia v1.14.0 adds Telegram auth helpers and supports `CLAUDE_CODE_OAUTH_TOKEN` for non-interactive Claude runs. Prefer `/setup_token` then `/use_oauth_token` if Telegram shows Claude auth/keychain errors.
 
 ### 2. Install Open Claudia
@@ -103,6 +111,7 @@ If installed as a background service, the bot starts automatically on login and
 |---------|-------------|
 | `/cursor` | Switch to Cursor Agent backend |
 | `/claude` | Switch to Claude Code backend |
+| `/codex` | Switch to OpenAI Codex backend |
 | `/backend` | Show current backend with picker |
 
 Each backend keeps its own persistent session. Switching doesn't lose your place — you can go back and forth freely.
@@ -167,20 +176,20 @@ Tokens are redacted from Telegram output and logs. If the encrypted vault is unl
 
 ## Backend Comparison
 
-| | Claude Code | Cursor Agent |
-|---|---|---|
-| Binary | `claude` | `agent` |
-| Session flag | `--resume <id>` | `--resume <id>` |
-| Auth | `claude auth` | `agent login` |
-| Plan mode | Yes (`--permission-mode plan`) | Yes (`--mode plan`) |
-| Ask mode | No | Yes (`--mode ask`) |
-| Budget control | Yes (`--max-budget-usd`) | No |
-| Effort levels | Yes | No |
-| Worktree | Yes (`--worktree`) | Yes (`--worktree`) |
-| Model switching | Yes | Yes |
-| Dangerously skip permissions | Yes | Yes (`--trust`) |
-
-Both backends output `stream-json` which Open Claudia parses for real-time progress updates.
+| | Claude Code | Cursor Agent | OpenAI Codex |
+|---|---|---|---|
+| Binary | `claude` | `agent` | `codex` |
+| Session flag | `--resume <id>` | `--resume <id>` | `exec resume <id>` |
+| Auth | `claude auth` | `agent login` | `codex login` |
+| Plan mode | Yes (`--permission-mode plan`) | Yes (`--mode plan`) | Yes (`--sandbox read-only`) |
+| Ask mode | No | Yes (`--mode ask`) | No |
+| Budget control | Yes (`--max-budget-usd`) | No | No |
+| Effort levels | Yes | No | Via config.toml |
+| Worktree | Yes (`--worktree`) | Yes (`--worktree`) | No |
+| Model switching | Yes | Yes | Yes (`--model`) |
+| Dangerously skip permissions | Yes | Yes (`--trust`) | Yes (`--dangerously-bypass-approvals-and-sandbox`) |
+
+All three backends output structured JSON which Open Claudia parses for real-time progress updates (Claude/Cursor: `stream-json`; Codex: JSONL events).
 
 ## Sending Files
 
@@ -258,6 +267,7 @@ All stored in `~/.open-claudia/`:
 | `WORKSPACE` | Yes | Path to your projects directory |
 | `CLAUDE_PATH` | Yes | Path to Claude Code CLI binary |
 | `CURSOR_PATH` | No | Path to Cursor Agent CLI binary (auto-detected if in PATH) |
+| `CODEX_PATH` | No | Path to OpenAI Codex CLI binary (auto-detected if in PATH) |
 | `WHISPER_CLI` | No | Path to whisper.cpp binary |
 | `WHISPER_MODEL` | No | Whisper model to use |
 | `FFMPEG` | No | Path to ffmpeg binary |

package/bot.js

@@ -143,6 +143,7 @@ const CHAT_ID = CHAT_IDS[0]; // Primary owner chat for crons/notifications
 const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
+const CODEX_PATH = config.CODEX_PATH || null;
 
 // Validate critical config at startup
 if (!TOKEN) { console.error("TELEGRAM_BOT_TOKEN not set"); process.exit(1); }
@@ -180,6 +181,15 @@ if (!resolvedCursorPath) {
   } catch (e) { resolvedCursorPath = null; }
 }
 if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
+
+// Resolve Codex CLI (optional — discovered at startup)
+let resolvedCodexPath = CODEX_PATH;
+if (!resolvedCodexPath) {
+  try {
+    resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null;
+  } catch (e) { resolvedCodexPath = null; }
+}
+if (resolvedCodexPath) console.log(`Codex CLI: ${resolvedCodexPath}`);
 const WHISPER_CLI = config.WHISPER_CLI || "";
 const WHISPER_MODEL = config.WHISPER_MODEL || "";
 const FFMPEG = config.FFMPEG || "";
@@ -193,6 +203,7 @@ const BOT_DIR = __dirname;
 const FULL_PATH = [
   path.dirname(CLAUDE_PATH),
   resolvedCursorPath ? path.dirname(resolvedCursorPath) : null,
+  resolvedCodexPath ? path.dirname(resolvedCodexPath) : null,
   path.dirname(process.execPath),
   FFMPEG ? path.dirname(FFMPEG) : null,
   WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
@@ -274,6 +285,7 @@ bot.setMyCommands([
   { command: "ask", description: "Toggle ask mode (Cursor only)" },
   { command: "sessions", description: "List conversations for this project" },
   { command: "compact", description: "Summarize conversation context" },
+  { command: "usage", description: "Show token usage & cost for this session" },
   { command: "continue", description: "Resume last conversation" },
   { command: "worktree", description: "Toggle isolated git branch" },
   { command: "cron", description: "Manage scheduled tasks" },
@@ -282,6 +294,7 @@ bot.setMyCommands([
   { command: "status", description: "Session & settings info" },
   { command: "cursor", description: "Switch to Cursor Agent backend" },
   { command: "claude", description: "Switch to Claude Code backend" },
+  { command: "codex", description: "Switch to OpenAI Codex backend" },
   { command: "backend", description: "Show/switch active backend" },
   { command: "auth_status", description: "Check Claude Code auth" },
   { command: "login", description: "Start Claude Code login" },
@@ -324,7 +337,9 @@ function saveState() {
     currentSession,
     lastSessionId,
     cursorSessionId,
+    codexSessionId,
     settings,
+    sessionUsage,
   };
   try { fs.writeFileSync(STATE_FILE, JSON.stringify(data)); } catch (e) {}
 }
@@ -393,6 +408,7 @@ let streamBuffer = "";
 let streamInterval = null;
 let lastSessionId = savedState.lastSessionId || null;
 let cursorSessionId = savedState.cursorSessionId || null;
+let codexSessionId = savedState.codexSessionId || null;
 let messageQueue = [];
 let activeCrons = new Map();
 let pendingVaultUnlock = false; // Waiting for password
@@ -402,6 +418,20 @@ let pendingClaudeAuthLabel = null;
 let isFirstMessage = !lastSessionId; // Track if this is first message in session
 let lastInputWasVoice = false; // Reply with voice when input was voice
 
+// Per-session usage tracking (resets on /end or new session)
+let sessionUsage = savedState.sessionUsage || {
+  turns: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheCreationTokens: 0,
+  costUsd: 0,
+  lastInputTokens: 0, // Last turn's input tokens (for compact suggestion)
+};
+function resetSessionUsage() {
+  sessionUsage = { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+}
+
 let settings = savedState.settings || {
   model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude",
 };
@@ -949,7 +979,7 @@ function claudeAuthRecoveryMessage(reason = "Claude Code authentication failed")
 }
 
 function preflightClaudeAuthMessage() {
-  if (settings.backend === "cursor") return null;
+  if (settings.backend !== "claude") return null;
   if (getClaudeOAuthToken().value) return null;
   try {
     const output = execSync(`"${CLAUDE_PATH}" auth status`, {
@@ -1144,6 +1174,7 @@ function parseStreamEvents(data) {
 
 function buildClaudeArgs(prompt, opts = {}) {
   if (settings.backend === "cursor") return buildCursorArgs(prompt, opts);
+  if (settings.backend === "codex") return buildCodexArgs(prompt, opts);
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
   if (opts.continueSession) args.push("--continue");
@@ -1170,13 +1201,40 @@ function buildCursorArgs(prompt, opts = {}) {
   return args;
 }
 
+function buildCodexArgs(prompt, opts = {}) {
+  // Codex uses `exec [SESSION] [PROMPT]` or `exec resume <SESSION> [PROMPT]`.
+  // Sandbox: bot runs headless, so bypass approvals (mirrors --dangerously-skip-permissions).
+  // Plan mode: drop to read-only sandbox so the model can't write.
+  const args = [];
+  const resumeId = (!opts.fresh && !opts.continueSession) ? codexSessionId : null;
+  if (opts.continueSession && codexSessionId) {
+    args.push("exec", "resume", codexSessionId);
+  } else if (resumeId) {
+    args.push("exec", "resume", resumeId);
+  } else {
+    args.push("exec");
+  }
+  args.push("--json", "--skip-git-repo-check");
+  if (settings.permissionMode === "plan") {
+    args.push("--sandbox", "read-only");
+  } else {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  if (settings.model) args.push("--model", settings.model);
+  args.push(prompt);
+  return args;
+}
+
 function getActiveBinary() {
   if (settings.backend === "cursor") return resolvedCursorPath;
+  if (settings.backend === "codex") return resolvedCodexPath;
   return CLAUDE_PATH;
 }
 
 function getActiveSessionId() {
-  return settings.backend === "cursor" ? cursorSessionId : lastSessionId;
+  if (settings.backend === "cursor") return cursorSessionId;
+  if (settings.backend === "codex") return codexSessionId;
+  return lastSessionId;
 }
 
 async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
@@ -1321,9 +1379,59 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           currentToolDetail = "";
         }
       }
+      // Codex stream events
+      if (evt.type === "thread.started" && evt.thread_id) {
+        codexSessionId = evt.thread_id;
+        saveState();
+      }
+      if (evt.type === "item.started" && evt.item) {
+        const it = evt.item;
+        if (it.type === "command_execution" && it.command) {
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = String(it.command).slice(0, 80);
+        } else if (it.type === "file_change" && (it.path || it.file_path)) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          const p = it.path || it.file_path;
+          currentToolDetail = String(p).split("/").slice(-2).join("/");
+        } else if (it.type === "web_search" && it.query) {
+          currentTool = "Web"; toolUses.push("Web");
+          currentToolDetail = String(it.query).slice(0, 60);
+        } else if (it.type) {
+          currentTool = it.type; toolUses.push(it.type);
+          currentToolDetail = "";
+        }
+      }
+      if (evt.type === "item.completed" && evt.item) {
+        const it = evt.item;
+        if (it.type === "agent_message" && typeof it.text === "string") {
+          assistantText += (assistantText ? "\n" : "") + it.text;
+        }
+      }
+      if (evt.type === "turn.completed" && evt.usage && settings.backend === "codex") {
+        sessionUsage.turns += 1;
+        const input = evt.usage.input_tokens || 0;
+        const cached = evt.usage.cached_input_tokens || 0;
+        const output = evt.usage.output_tokens || 0;
+        sessionUsage.inputTokens += input;
+        sessionUsage.outputTokens += output;
+        sessionUsage.cacheReadTokens += cached;
+        sessionUsage.lastInputTokens = input + cached;
+        saveState();
+      }
       if (evt.type === "result" && evt.session_id) {
         if (settings.backend === "cursor") { cursorSessionId = evt.session_id; }
         else { lastSessionId = evt.session_id; }
+        if (evt.usage) {
+          sessionUsage.turns += 1;
+          sessionUsage.inputTokens += evt.usage.input_tokens || 0;
+          sessionUsage.outputTokens += evt.usage.output_tokens || 0;
+          sessionUsage.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
+          sessionUsage.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
+          sessionUsage.lastInputTokens = (evt.usage.input_tokens || 0) +
+            (evt.usage.cache_read_input_tokens || 0) +
+            (evt.usage.cache_creation_input_tokens || 0);
+        }
+        if (typeof evt.total_cost_usd === "number") sessionUsage.costUsd += evt.total_cost_usd;
         saveState();
       }
       if (evt.type === "result" && evt.result) assistantText = evt.result;
@@ -1343,7 +1451,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     clearTimeout(processTimeout);
 
     // Check for auth errors in stderr and give actionable Telegram recovery steps.
-    if (settings.backend !== "cursor" && isClaudeAuthErrorText(stderrBuffer)) {
+    if (settings.backend === "claude" && isClaudeAuthErrorText(stderrBuffer)) {
       await send(claudeAuthRecoveryMessage(stderrBuffer.trim().slice(-800)), { replyTo: replyToMsgId });
       return;
     }
@@ -1351,6 +1459,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       await send("Cursor authentication error. Run `agent login` on this machine, then retry.", { replyTo: replyToMsgId });
       return;
     }
+    if (settings.backend === "codex" && /not (?:logged in|authenticated)|please (?:log|sign) in|401 unauthorized|invalid api key/i.test(stderrBuffer)) {
+      await send("Codex authentication error. Run `codex login` on this machine, then retry.", { replyTo: replyToMsgId });
+      return;
+    }
 
     try {
       if (code !== 0 && code !== null && !assistantText.trim()) {
@@ -1384,6 +1496,15 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         const voicePath = textToVoice(finalText);
         if (voicePath) await sendVoice(voicePath);
       }
+
+      // Suggest /compact when context gets large (once per threshold crossing)
+      const ctx = sessionUsage.lastInputTokens;
+      if (ctx > 150000 && !sessionUsage.warnedHighContext) {
+        sessionUsage.warnedHighContext = true;
+        await send(`Heads up: context is ${(ctx / 1000).toFixed(0)}k tokens. Use /compact to summarize or /end for a fresh start — keeps cost down.`);
+      } else if (ctx < 80000 && sessionUsage.warnedHighContext) {
+        sessionUsage.warnedHighContext = false;
+      }
     } catch (e) {
       console.error("Final message delivery failed:", e.message);
       await send("Task completed but failed to deliver the response. Send /continue to see the result.");
@@ -1629,16 +1750,29 @@ bot.onText(/\/sessions$/, (msg) => {
 
 bot.onText(/\/model$/, (msg) => {
   if (!isAuthorized(msg)) return;
-  const keyboard = settings.backend === "cursor" ? [
-    [{ text: "Composer 2", callback_data: "m:composer-2" }, { text: "Composer 2 Fast", callback_data: "m:composer-2-fast" }],
-    [{ text: "Opus 4.6 Thinking", callback_data: "m:claude-4.6-opus-high-thinking" }, { text: "Sonnet 4.6", callback_data: "m:claude-4.6-sonnet-medium" }],
-    [{ text: "GPT-5.4", callback_data: "m:gpt-5.4-medium" }, { text: "GPT-5.4 High", callback_data: "m:gpt-5.4-high" }],
-    [{ text: "Auto", callback_data: "m:auto" }, { text: "Default", callback_data: "m:default" }],
-  ] : [
-    [{ text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }, { text: "Opus 4.6", callback_data: "m:claude-opus-4-6" }, { text: "Sonnet 4.6", callback_data: "m:claude-sonnet-4-6" }, { text: "Haiku", callback_data: "m:claude-haiku-4-5-20251001" }],
-    [{ text: "Default", callback_data: "m:default" }],
-  ];
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
+  let keyboard, label;
+  if (settings.backend === "cursor") {
+    keyboard = [
+      [{ text: "Composer 2", callback_data: "m:composer-2" }, { text: "Composer 2 Fast", callback_data: "m:composer-2-fast" }],
+      [{ text: "Opus 4.6 Thinking", callback_data: "m:claude-4.6-opus-high-thinking" }, { text: "Sonnet 4.6", callback_data: "m:claude-4.6-sonnet-medium" }],
+      [{ text: "GPT-5.4", callback_data: "m:gpt-5.4-medium" }, { text: "GPT-5.4 High", callback_data: "m:gpt-5.4-high" }],
+      [{ text: "Auto", callback_data: "m:auto" }, { text: "Default", callback_data: "m:default" }],
+    ];
+    label = "Cursor Agent";
+  } else if (settings.backend === "codex") {
+    keyboard = [
+      [{ text: "gpt-5", callback_data: "m:gpt-5" }, { text: "gpt-5-codex", callback_data: "m:gpt-5-codex" }],
+      [{ text: "o3", callback_data: "m:o3" }, { text: "o4-mini", callback_data: "m:o4-mini" }],
+      [{ text: "Default", callback_data: "m:default" }],
+    ];
+    label = "Codex";
+  } else {
+    keyboard = [
+      [{ text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }, { text: "Opus 4.6", callback_data: "m:claude-opus-4-6" }, { text: "Sonnet 4.6", callback_data: "m:claude-sonnet-4-6" }, { text: "Haiku", callback_data: "m:claude-haiku-4-5-20251001" }],
+      [{ text: "Default", callback_data: "m:default" }],
+    ];
+    label = "Claude Code";
+  }
   send(`${label} model: ${settings.model || "default"}\n\nOr type /model <name> for any model.`, { keyboard: { inline_keyboard: keyboard } });
 });
 bot.onText(/\/model (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; settings.model = match[1].trim().toLowerCase(); if (settings.model === "default") settings.model = null; send(`Model: ${settings.model || "default"}`); });
@@ -1646,6 +1780,7 @@ bot.onText(/\/model (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; set
 bot.onText(/\/effort$/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
+  if (settings.backend === "codex") return send("Effort levels are not exposed as a flag on Codex.\nSet `model_reasoning_effort` in ~/.codex/config.toml, or switch to /claude.");
   send(`Effort: ${settings.effort || "default"}`, { keyboard: { inline_keyboard: [
     [{ text: "Low", callback_data: "e:low" }, { text: "Med", callback_data: "e:medium" }, { text: "High", callback_data: "e:high" }, { text: "Max", callback_data: "e:max" }],
     [{ text: "Default", callback_data: "e:default" }],
@@ -1654,12 +1789,14 @@ bot.onText(/\/effort$/, (msg) => {
 bot.onText(/\/effort (.+)/, (msg, match) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.");
+  if (settings.backend === "codex") return send("Effort levels are not exposed as a flag on Codex.");
   const e = match[1].trim().toLowerCase(); settings.effort = ["low","medium","high","max"].includes(e) ? e : null; send(`Effort: ${settings.effort || "default"}`);
 });
 
 bot.onText(/\/budget$/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
+  if (settings.backend === "codex") return send("Budget limits are not supported on Codex.\nSwitch to Claude with /claude to use this.");
   send(`Budget: ${settings.budget ? "$" + settings.budget : "none"}`, { keyboard: { inline_keyboard: [
     [{ text: "$1", callback_data: "b:1" }, { text: "$5", callback_data: "b:5" }, { text: "$10", callback_data: "b:10" }, { text: "$25", callback_data: "b:25" }],
     [{ text: "No limit", callback_data: "b:none" }],
@@ -1668,6 +1805,7 @@ bot.onText(/\/budget$/, (msg) => {
 bot.onText(/\/budget (.+)/, (msg, match) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.");
+  if (settings.backend === "codex") return send("Budget limits are not supported on Codex.");
   const v = parseFloat(match[1].replace("$","")); settings.budget = v > 0 ? v : null; send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`);
 });
 
@@ -1675,8 +1813,14 @@ bot.onText(/\/plan$/, (msg) => {
   if (!isAuthorized(msg)) return;
   const p = settings.permissionMode === "plan";
   settings.permissionMode = p ? null : "plan";
-  const label = settings.backend === "cursor" ? "read-only planning, no edits" : "plan permission mode";
-  if (p) cursorSessionId = null; // reset session so next message doesn't resume plan-mode session
+  const label = settings.backend === "cursor" ? "read-only planning, no edits"
+    : settings.backend === "codex" ? "read-only sandbox, no edits"
+    : "plan permission mode";
+  if (p) {
+    // Reset session so next message doesn't resume in plan-mode for the active backend.
+    if (settings.backend === "cursor") cursorSessionId = null;
+    else if (settings.backend === "codex") codexSessionId = null;
+  }
   send(p ? "Plan mode off (session reset)." : `Plan mode on (${label}).`);
 });
 bot.onText(/\/ask$/, (msg) => {
@@ -1697,7 +1841,7 @@ bot.onText(/\/cursor$/, async (msg) => {
   settings.model = null;
   saveState();
   const sid = cursorSessionId ? `\nSession: ${cursorSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back`);
+  send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back · /codex — Codex`);
 });
 
 bot.onText(/\/claude$/, async (msg) => {
@@ -1706,15 +1850,26 @@ bot.onText(/\/claude$/, async (msg) => {
   settings.model = null;
   saveState();
   const sid = lastSessionId ? `\nSession: ${lastSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Claude Code.${sid}\n\n/cursor — switch to Cursor`);
+  send(`Switched to Claude Code.${sid}\n\n/cursor — Cursor · /codex — Codex`);
+});
+
+bot.onText(/\/codex$/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!resolvedCodexPath) return send("Codex CLI not found.\nInstall: npm install -g @openai/codex\nThen run `codex login` to authenticate.");
+  settings.backend = "codex";
+  settings.model = null;
+  saveState();
+  const sid = codexSessionId ? `\nSession: ${codexSessionId.slice(0, 8)}...` : "\nNew session.";
+  send(`Switched to Codex.${sid}\n\n/claude — Claude · /cursor — Cursor`);
 });
 
 bot.onText(/\/backend$/, async (msg) => {
   if (!isAuthorized(msg)) return;
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
+  const label = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
   const cursorAvail = resolvedCursorPath ? "available" : "not found";
-  send(`Backend: ${label}\n\nClaude Code: available\nCursor Agent: ${cursorAvail}`, { keyboard: { inline_keyboard: [
-    [{ text: "Claude Code", callback_data: "be:claude" }, { text: "Cursor Agent", callback_data: "be:cursor" }],
+  const codexAvail = resolvedCodexPath ? "available" : "not found";
+  send(`Backend: ${label}\n\nClaude Code: available\nCursor Agent: ${cursorAvail}\nCodex: ${codexAvail}`, { keyboard: { inline_keyboard: [
+    [{ text: "Claude Code", callback_data: "be:claude" }, { text: "Cursor Agent", callback_data: "be:cursor" }, { text: "Codex", callback_data: "be:codex" }],
   ] } });
 });
 
@@ -1747,7 +1902,7 @@ bot.onText(/\/stop/, async (msg) => {
 bot.onText(/\/status/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
-  const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
+  const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
   send([
     `Project: ${currentSession.name}`,
     `Backend: ${backendLabel}`,
@@ -1760,12 +1915,28 @@ bot.onText(/\/status/, (msg) => {
 bot.onText(/\/end/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (currentSession) {
-    const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings();
+    const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); resetSessionUsage();
     saveState();
     send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New session", callback_data: "show:projects" }]] } });
   } else send("No session.");
 });
 
+bot.onText(/\/usage$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  const u = sessionUsage;
+  if (u.turns === 0) return send("No usage yet in this session.");
+  const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n);
+  const lines = [
+    `*Session usage* (${u.turns} turn${u.turns === 1 ? "" : "s"})`,
+    `Input: ${fmt(u.inputTokens)} · Output: ${fmt(u.outputTokens)}`,
+    `Cache read: ${fmt(u.cacheReadTokens)} · Cache write: ${fmt(u.cacheCreationTokens)}`,
+    `Cost: $${u.costUsd.toFixed(4)}`,
+    `Last turn context: ${fmt(u.lastInputTokens)}`,
+  ];
+  if (u.lastInputTokens > 100000) lines.push("\nTip: context is large. Use /compact to summarize, or /end for a clean slate.");
+  send(lines.join("\n"), { parseMode: "Markdown" });
+});
+
 bot.onText(/\/soul$/, async (msg) => {
   if (!isAuthorized(msg)) return;
   const soul = loadSoul();
@@ -1965,23 +2136,24 @@ bot.on("callback_query", async (q) => {
     const sessions = loadSessions();
     // Don't delete history, just start fresh
     currentSession = { name: proj === "__workspace__" ? "Workspace" : proj, dir: proj === "__workspace__" ? WORKSPACE : path.join(WORKSPACE, proj) };
-    lastSessionId = null; isFirstMessage = true; messageQueue = []; resetSettings();
+    lastSessionId = null; isFirstMessage = true; messageQueue = []; resetSettings(); resetSessionUsage();
     saveState();
     await send(`Session: ${currentSession.name}\nNew conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
     return;
   }
   if (d === "a:continue") { if (currentSession) await runClaude("continue", currentSession.dir); else send("No session."); return; }
-  if (d === "a:end") { if (currentSession) { const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); saveState(); await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } }); } return; }
+  if (d === "a:end") { if (currentSession) { const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); resetSessionUsage(); saveState(); await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } }); } return; }
   if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
   if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
   if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
   if (d.startsWith("be:")) {
     const be = d.slice(3);
     if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
+    if (be === "codex" && !resolvedCodexPath) { await send("Codex CLI not found. Install: npm install -g @openai/codex"); return; }
     settings.backend = be;
     settings.model = null;
     saveState();
-    const label = be === "cursor" ? "Cursor Agent" : "Claude Code";
+    const label = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
     await send(`Switched to ${label}.`);
     return;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.14.9",
-  "description": "Your always-on AI coding assistant — Claude Code via Telegram",
+  "version": "1.16.0",
+  "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram",
   "main": "bot.js",
   "bin": {
     "open-claudia": "./bin/cli.js"