@inetafrica/open-claudia 2.6.29 → 2.6.31

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## v2.6.30
+- **Cluster self-management for AgentSpace pods.** When running as an AgentSpace pod, the bot can inspect and manage its own deployment through the backend broker — `/cluster status|logs [n]|restart|start|stop|scale <0|1>|sync` (owner-gated) for humans, and `open-claudia cluster …` for the agent. Both are thin clients over `core/cluster-client.js`, which posts to the broker's capability-gated `/pods/self/cluster` endpoint with the pod's bearer token; the bot holds no Kubernetes credentials. `brokerConfigured()` requires both `AGENTSPACE_API_URL` and `AGENTSPACE_POD_TOKEN`, so an unconfigured local install safely replies "not available" while a provisioned pod reaches the broker. Also tightens the `core/pack-guard.js` exfil heuristic: the broad "URL co-occurring with a sensitive word" rule (which false-positived on legitimate infra notes) is replaced by two precise carriers — a send/store/upload verb pointed at a URL/address, and a credential attached directly to a URL as a query/fragment param.
+
+## v2.6.29
+- **Kazee channel hardening.** `send()` now retries up to 3× with 1s/2s backoff (skipping 4xx), `edit()` normalizes text the same way as `send()`, inbound handling is async and detects ogg/opus voice notes (promoting them from "audio" to "voice" so the router dispatches correctly), reply-to context best-effort fetches the replied-to message before emitting the envelope, and `format.js` converts stray Telegram HTML tags (`<b>`, `<code>`, `<pre>`, `<i>`, `<s>`, `<a>`) to Markdown as a safety net.
+
+## v2.6.28
+- **Usage: report true peak context, not the inflated per-turn sum.** The result event re-counted the cached prefix once per tool round-trip, so `contextTokens` ballooned into the millions and the "Context this turn" alert fired every turn. It now tracks the peak single-call prefix (input + cache_read + cache_creation) and reports that as `contextTokens`; the summed value is kept as `billedContextTokens` for cost attribution.
+
+## v2.6.27
+- **Tasks: recency-ranked injection, staleness footer, and dream hygiene.** Open-task injection now ranks by activity (max of root and child `updatedAt`) rather than status — the most-recently-worked render in full, colder ones render title-only with a `task get <id>` pointer (new accessor + loopback endpoint + CLI sub), and anything untouched >14d (`OPEN_CLAUDIA_TASK_STALE_DAYS`) collapses into a capped one-line stale footer. The dream pass gains a task-hygiene step that surfaces the stalest tasks in the morning report — flag-and-ask only; it never edits or deletes tasks.
+
+## v2.6.26
+- **Memory: threat-scan guard + FTS-miss instrumentation.** `core/pack-guard.js` scans reviewer/dream content before write (override/exfil/base64 heuristics; strict on the auto-injected Stance/Procedure/State/description, lenient on Journal) and is wired into the pack reviewer and dream merge/umbrella/retag — a hit skips the write and announces one line. `logRecall` now records FTS-miss rescues (packs the judge kept that FTS scored ~0) into `recall-stats.json`, so a vector backend becomes a data-driven decision.
+
+## v2.6.25
+- **Memory: provenance tracking for pack writes.** A per-pack `.provenance.json` sidecar records which origin (user / reviewer / dream) last authored each section; `updatePack`/`createPack` take an origin, and an automated writer never silently overwrites a user-authored Stance. An absent sidecar defaults to "user" (protect-by-default).
+
+## v2.6.24
+- **Memory: pack usage telemetry + lifecycle retirement.** Packs gain `usage_count` telemetry (bumped on each use alongside `last_used`), a dream archive action retires cold packs (idle ≥30d, used ≤3×) into `.archived` with safety guards, and `pack archive`/`restore`/`archived` CLI commands are added; `/skills` surfaces the archived count. Also adds a post-dream chat summary (`DREAM_SUMMARY`), toggled with the new `/dreamsummary on|off` command (default on); when off, the nightly consolidation runs silently.
+
+## v2.6.23
+- **Progressive pack disclosure on by default.** Injects Stance + State teasers with on-demand Procedure/Journal and widens the pack match limit to 6. Override with `PACK_PROGRESSIVE=off`.
+
+## v2.6.22
+- **Wire `/skills` and `/learn` into the context-pack store.** Both previously read from / wrote to the empty legacy `~/.claude/skills` dir; now `/skills` lists packs with show/remove, and `/learn` folds work into a matching pack's Procedure plus a dated Journal line.
+
+## v2.6.21
+- **CI: allow tests to run without bot env.** The test suite no longer requires bot environment variables to be present.
+
 ## v2.6.20
 - **AgentSpace pod durability.** `/upgrade` and password-change callbacks now preserve the `/api` base path expected by AgentSpace, CLI paths are resolved to concrete executables at startup, and runs repair a stale/missing session workspace before spawning Claude, Cursor, or Codex. This prevents misleading `spawn ... ENOENT` failures when the saved session cwd no longer exists.
 

package/README.md

@@ -47,6 +47,7 @@ Send text, voice notes, screenshots, and files from your phone. Your chosen AI a
 - **Token economy** — byte-stable system prompt for maximum Anthropic prompt-cache hits; dynamic state rides each message instead
 - **Web UI** — optional browser UI for setup and config (`open-claudia start --web`)
 - **Auto-updates** — checks npm every 5 minutes, upgrade with `/upgrade`
+- **Cluster self-management** — when running as an AgentSpace pod, the bot can inspect and manage its own deployment (`/cluster`, or `open-claudia cluster …` for the agent) through the broker, which authenticates, capability-checks, and audits every operation
 - **Requirements doctor** — `/doctor` checks CLI installs, auth, voice tools, and writable paths
 - **Cross-platform** — macOS, Linux, and Windows
 
@@ -187,6 +188,7 @@ When you select a project, the last conversation is automatically resumed. Tap "
 | `/learn [<hint>]` | Capture the last piece of work into the matching context pack |
 | `/skills [show\|remove <name>]` | List, show, or remove legacy learned skills |
 | `/soul` | View/edit assistant identity and personality |
+| `/dreamsummary [on\|off]` | Toggle the post-dream memory summary in chat |
 
 ### Automation
 
@@ -235,9 +237,23 @@ Tokens are redacted from chat output and logs.
 | `/version` | Show current running version |
 | `/upgrade` | Upgrade to latest version and restart (includes a post-upgrade doctor summary) |
 | `/restart` | Restart the bot |
+| `/dashboard` | Get a one-time login link to the web dashboard |
 | `/stop` | Cancel a running task |
 | `/help` | Show all commands |
 
+### Cluster control
+
+Available only when the bot runs as an AgentSpace-provisioned pod (the broker credentials `AGENTSPACE_API_URL` and `AGENTSPACE_POD_TOKEN` are present). Off this network the command replies that it isn't available and does nothing. Owner-gated; every operation is authenticated, capability-checked, and audited by the broker, and confined to the bot's own deployment.
+
+| Command | Description |
+|---------|-------------|
+| `/cluster status` | Deployment readiness/phase |
+| `/cluster logs [n]` | Tail the last n container log lines |
+| `/cluster restart` | Rollout restart (pulls latest image) |
+| `/cluster start` / `/cluster stop` | Scale to 1 / 0 replicas |
+| `/cluster scale <0\|1>` | Stop (0) or start (1) |
+| `/cluster sync` | Re-apply the deployment manifest |
+
 ## Memory & Long-Term Context
 
 Open Claudia layers three memory systems on top of the backend's native sessions:

package/bin/cli.js

@@ -274,6 +274,11 @@ switch (command) {
     break;
   }
 
+  case "cluster": {
+    require("./cluster").run(args.slice(1));
+    break;
+  }
+
   case "pack": {
     require("./pack").run(args.slice(1));
     break;
@@ -347,6 +352,9 @@ Background work (only inside an active bot-spawned task):
   open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
   open-claudia agent "<prompt>" [--role X]         Spawn a throwaway sub-agent for research
 
+Cluster control (self-management of this bot's own deployment via the broker):
+  open-claudia cluster status|logs|restart|start|stop|scale <0|1>|sync
+
 Multi-user / cross-channel:
   open-claudia people list|show|add|note|link      Roster of known team members
   open-claudia intros list|approve|reject          Pending introductions from unknown chats

package/bin/cluster.js

@@ -0,0 +1,75 @@
+// open-claudia cluster <operation>
+//
+// Self-management of this bot's own Kubernetes deployment, mediated by the
+// AgentSpace broker. The bot has no direct cluster credentials — every command
+// here is a request the broker authenticates, capability-checks, audits, and
+// executes against the pod's own namespace.
+
+const { clusterRequest } = require("../core/cluster-client");
+
+const HELP = `
+Cluster control for this bot's own deployment (via the AgentSpace broker).
+
+  open-claudia cluster status            Show deployment readiness/phase
+  open-claudia cluster logs [n]          Tail the last n container log lines (default 100, max 1000)
+  open-claudia cluster restart           Rollout restart (pulls latest image)
+  open-claudia cluster start             Scale to 1 replica
+  open-claudia cluster stop              Scale to 0 replicas
+  open-claudia cluster scale <0|1>       Stop (0) or start (1)
+  open-claudia cluster sync              Re-apply the deployment manifest
+
+All operations are confined to this pod's own namespace and gated by the
+capabilities the broker has granted this bot.
+`;
+
+function ok(line) { if (line) console.log(line); process.exit(0); }
+function fail(line) { if (line) console.error(line); process.exit(1); }
+
+// Render a broker response into a human line + correct exit code.
+function report(res, successLine) {
+  if (res.status >= 200 && res.status < 300) {
+    ok(typeof successLine === "function" ? successLine(res.json || {}) : successLine);
+  }
+  const detail = res.json && res.json.error ? res.json.error : (res.body || "").slice(0, 400);
+  if (res.status === 0) fail(`Broker request failed: ${detail}`);
+  fail(`Broker ${res.status}: ${detail}`);
+}
+
+async function run(args) {
+  const op = (args[0] || "").toLowerCase();
+  const rest = args.slice(1);
+  if (!op || op === "help" || op === "--help") { console.log(HELP); process.exit(op ? 0 : 2); }
+
+  switch (op) {
+    case "status": {
+      const res = await clusterRequest("status");
+      return report(res, (j) =>
+        `Deployment: ${j.phase || "?"}${j.ready ? " (ready)" : ""}${j.message ? ` — ${j.message}` : ""}`);
+    }
+    case "logs": {
+      const tailLines = rest[0] ? parseInt(rest[0], 10) : undefined;
+      if (rest[0] && Number.isNaN(tailLines)) fail("Usage: cluster logs [n]  (n = number of lines)");
+      const res = await clusterRequest("logs", tailLines ? { tailLines } : {});
+      return report(res, (j) => (j.logs || "(no logs)"));
+    }
+    case "restart":
+      return report(await clusterRequest("restart"), (j) => j.message || "Restart requested.");
+    case "start":
+      return report(await clusterRequest("start"), (j) => j.message || "Started.");
+    case "stop":
+      return report(await clusterRequest("stop"), (j) => j.message || "Stopped.");
+    case "scale": {
+      const n = rest[0];
+      if (n !== "0" && n !== "1") fail("Usage: cluster scale <0|1>");
+      return report(await clusterRequest("scale", { replicas: parseInt(n, 10) }), (j) => j.message || `Scaled to ${n}.`);
+    }
+    case "sync":
+      return report(await clusterRequest("sync"), (j) => j.message || "Reconciled.");
+    default:
+      console.error(`Unknown cluster operation: ${op}`);
+      console.log(HELP);
+      process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/core/actions.js

@@ -19,6 +19,9 @@ const { finishOnboarding } = require("./onboarding");
 const { startSession } = require("./handlers");
 const jobs = require("./jobs");
 const scheduler = require("./scheduler");
+const {
+  getClaudeOAuthToken, runClaudeAuthCommand, runCodexLoginStatus, runCodexDeviceLogin,
+} = require("./auth-flow");
 
 async function handleAction(envelope) {
   const adapter = envelope.adapter;
@@ -251,6 +254,20 @@ async function handleAction(envelope) {
     state.settings.model = model;
     saveState();
     const beLabel = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
+    // Auth-aware: if the chosen provider isn't connected, start its login flow
+    // now. The model is already set, so once auth completes the user is on it.
+    if (be === "claude" && !getClaudeOAuthToken().value) {
+      if (!isChatOwner(envelope.channelId)) { await send("Claude isn't connected and only the owner can sign it in."); return; }
+      await send(`Set to ${model}, but Claude isn't connected yet. Starting login — open the URL I send, then paste the code here.`);
+      await runClaudeAuthCommand(["auth", "login", "--claudeai"], "Claude login");
+      return;
+    }
+    if (be === "codex" && !runCodexLoginStatus().ok) {
+      if (!isChatOwner(envelope.channelId)) { await send("Codex isn't connected and only the owner can sign it in."); return; }
+      await send(`Set to ${model}, but Codex isn't connected yet. Starting device login — open the URL and enter the code I send.`);
+      await runCodexDeviceLogin();
+      return;
+    }
     await send(switched ? `Switched to ${beLabel}.\nModel: ${model}` : `Model: ${model}`);
     return;
   }

package/core/auth-flow.js

@@ -317,6 +317,16 @@ function runCodexLoginStatus() {
   return { ...result, ok: result.ok && !isCodexAuthErrorText(result.output) };
 }
 
+// Quick "is this provider usable non-interactively" check for the unified
+// /login model picker. Claude is cheap (token presence is what the bot relies
+// on). Codex spawns `codex login status` once — fine for a setup screen.
+function providerAuthStatus() {
+  return {
+    claude: !!getClaudeOAuthToken().value,
+    codex: resolvedCodexPath ? runCodexLoginStatus().ok : false,
+  };
+}
+
 async function sendCodexAuthStatusSummary(prefix = "Codex auth status") {
   const status = runCodexLoginStatus();
   const version = resolvedCodexPath ? runCommand(resolvedCodexPath, ["--version"]) : { ok: false, output: "not found" };
@@ -427,6 +437,7 @@ module.exports = {
   clearPendingCodexAuth,
   runCommand,
   runCodexLoginStatus,
+  providerAuthStatus,
   sendCodexAuthStatusSummary,
   saveCodexApiKeyWithCli,
   runCodexDeviceLogin,

package/core/cluster-client.js

@@ -0,0 +1,79 @@
+// Thin client for the AgentSpace cluster-control broker.
+//
+// Both entry points use this single implementation:
+//   - bin/cluster.js  (the `open-claudia cluster ...` CLI, driven by the agent)
+//   - core/handlers.js (the `/cluster` Telegram slash command, driven by a human)
+//
+// The bot holds no Kubernetes credentials. It authenticates to the broker as
+// itself with the pod-self token; the broker enforces capabilities, policy and
+// audit and performs the actual cluster operation on the pod's own namespace.
+
+const CLUSTER_OPERATIONS = ["status", "logs", "restart", "start", "stop", "scale", "sync"];
+
+function brokerConfigured() {
+  return !!(process.env.AGENTSPACE_API_URL && process.env.AGENTSPACE_POD_TOKEN);
+}
+
+// Build the absolute URL to a pods/self/* endpoint, mirroring the path-base
+// logic used by the upgrade flow in core/handlers.js.
+function endpoint(pathSuffix) {
+  const apiUrl = process.env.AGENTSPACE_API_URL;
+  const base = new URL(apiUrl);
+  if (base.pathname === "/") base.pathname = "/api/";
+  if (!base.pathname.endsWith("/")) base.pathname += "/";
+  return new URL(pathSuffix, base);
+}
+
+// POST a cluster operation to the broker. Resolves to { status, body, json }.
+// Never rejects on HTTP/transport errors — surfaces them via status 0 so callers
+// can format a single error path.
+function clusterRequest(operation, params = {}) {
+  return new Promise((resolve) => {
+    if (!brokerConfigured()) {
+      resolve({
+        status: 0,
+        body: "AgentSpace broker not configured (AGENTSPACE_API_URL / AGENTSPACE_POD_TOKEN missing). This only works inside a pod provisioned by AgentSpace.",
+        json: null,
+      });
+      return;
+    }
+
+    let u;
+    try {
+      u = endpoint("pods/self/cluster");
+    } catch (e) {
+      resolve({ status: 0, body: `Bad AGENTSPACE_API_URL: ${e.message || e}`, json: null });
+      return;
+    }
+
+    const payload = JSON.stringify({ operation, ...params });
+    const lib = u.protocol === "https:" ? require("https") : require("http");
+    const req = lib.request(
+      {
+        method: "POST",
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname + u.search,
+        headers: {
+          Authorization: `Bearer ${process.env.AGENTSPACE_POD_TOKEN}`,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => { data += c; });
+        res.on("end", () => {
+          let json = null;
+          try { json = JSON.parse(data); } catch (e) {}
+          resolve({ status: res.statusCode, body: data, json });
+        });
+      }
+    );
+    req.on("error", (e) => resolve({ status: 0, body: String(e.message || e), json: null }));
+    req.setTimeout(20000, () => { req.destroy(new Error("timeout")); });
+    req.end(payload);
+  });
+}
+
+module.exports = { clusterRequest, brokerConfigured, CLUSTER_OPERATIONS };

package/core/handlers.js

@@ -38,7 +38,7 @@ const {
   sendClaudeAuthStatusSummary,
   runClaudeAuthCommand, clearPendingClaudeAuth,
   sendCodexAuthStatusSummary, runCodexDeviceLogin, clearPendingCodexAuth,
-  saveCodexApiKeyWithCli,
+  saveCodexApiKeyWithCli, providerAuthStatus,
 } = require("./auth-flow");
 
 const CURRENT_VERSION = require(path.join(__dirname, "..", "package.json")).version;
@@ -126,7 +126,8 @@ register({
       "Identity: /whoami /link",
       "Team: /people /intros /auth (owner)",
       "Automation: /cron /vault /soul /dreamsummary",
-      "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
+      "Connect: /login (pick model + sign in)",
+      "Claude auth: /auth_status /setup_token /use_oauth_token /clear_oauth_token",
       "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
       "System: /doctor /requirements /restart /upgrade",
       "",
@@ -525,6 +526,52 @@ register({
   },
 });
 
+register({
+  name: "cluster", description: "Control this bot's own deployment (status/logs/restart/start/stop/scale/sync)",
+  args: "<status|logs|restart|start|stop|scale 0|1|sync>", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return;
+    const { clusterRequest, brokerConfigured } = require("./cluster-client");
+    if (!brokerConfigured()) {
+      return send("Cluster control isn't available — this bot isn't running under AgentSpace (no broker credentials).");
+    }
+    const parts = (tail || "").trim().split(/\s+/).filter(Boolean);
+    const op = (parts[0] || "").toLowerCase();
+    const allowed = ["status", "logs", "restart", "start", "stop", "scale", "sync"];
+    if (!op || !allowed.includes(op)) {
+      return send("Usage: /cluster <status | logs [n] | restart | start | stop | scale 0|1 | sync>");
+    }
+    const params = {};
+    if (op === "logs" && parts[1]) {
+      const n = parseInt(parts[1], 10);
+      if (!Number.isNaN(n)) params.tailLines = n;
+    }
+    if (op === "scale") {
+      const n = parts[1];
+      if (n !== "0" && n !== "1") return send("Usage: /cluster scale <0|1>");
+      params.replicas = parseInt(n, 10);
+    }
+    try {
+      const res = await clusterRequest(op, params);
+      if (res.status >= 200 && res.status < 300) {
+        const j = res.json || {};
+        if (op === "status") {
+          return send(`Deployment: ${j.phase || "?"}${j.ready ? " (ready)" : ""}${j.message ? ` — ${j.message}` : ""}`);
+        }
+        if (op === "logs") {
+          const logs = j.logs || "(no logs)";
+          return send(logs.length > 3500 ? logs.slice(-3500) : logs);
+        }
+        return send(j.message || "Done.");
+      }
+      const detail = (res.json && res.json.error) ? res.json.error : (res.body || "").slice(0, 300);
+      return send(res.status === 0 ? `Cluster request failed: ${detail}` : `Cluster ${res.status}: ${detail}`);
+    } catch (e) {
+      return send(`Cluster error: ${e.message || e}`);
+    }
+  },
+});
+
 register({
   name: "projects", description: "Browse all workspace projects",
   handler: async (env) => { if (authorized(env)) send("Pick:", { keyboard: projectKeyboard() }); },
@@ -559,6 +606,57 @@ register({
   },
 });
 
+// Shared model picker used by /model and the unified /login. When authAware is
+// set, the provider section headers show connection status so the user knows a
+// tap on an unconnected provider will start its auth flow (handled in the mb:
+// callback in actions.js).
+function buildModelPicker({ authAware = false } = {}) {
+  const { settings } = currentState();
+  const auth = authAware ? providerAuthStatus() : null;
+  const mark = (ok) => authAware ? (ok ? " · connected" : " · tap to connect") : "";
+  const rows = [];
+  rows.push([{ text: `── Claude${mark(auth && auth.claude)} ──`, callback_data: "noop" }]);
+  rows.push([
+    { text: "Fable 5", callback_data: "mb:claude:claude-fable-5" },
+    { text: "Opus 4.8", callback_data: "mb:claude:claude-opus-4-8" },
+  ]);
+  rows.push([
+    { text: "Opus 4.7", callback_data: "mb:claude:claude-opus-4-7" },
+    { text: "Opus 4.6", callback_data: "mb:claude:claude-opus-4-6" },
+  ]);
+  rows.push([
+    { text: "Sonnet 4.6", callback_data: "mb:claude:claude-sonnet-4-6" },
+    { text: "Haiku", callback_data: "mb:claude:claude-haiku-4-5-20251001" },
+  ]);
+  if (resolvedCursorPath) {
+    rows.push([{ text: "── Cursor ──", callback_data: "noop" }]);
+    rows.push([
+      { text: "Composer 2", callback_data: "mb:cursor:composer-2" },
+      { text: "Composer 2 Fast", callback_data: "mb:cursor:composer-2-fast" },
+      { text: "Auto", callback_data: "mb:cursor:auto" },
+    ]);
+    rows.push([
+      { text: "Opus 4.6 Thinking", callback_data: "mb:cursor:claude-4.6-opus-high-thinking" },
+      { text: "GPT-5.4", callback_data: "mb:cursor:gpt-5.4-medium" },
+    ]);
+  }
+  if (resolvedCodexPath) {
+    rows.push([{ text: `── Codex${mark(auth && auth.codex)} ──`, callback_data: "noop" }]);
+    rows.push([
+      { text: "GPT-5.5", callback_data: "mb:codex:gpt-5.5" },
+      { text: "gpt-5", callback_data: "mb:codex:gpt-5" },
+      { text: "gpt-5-codex", callback_data: "mb:codex:gpt-5-codex" },
+    ]);
+    rows.push([
+      { text: "o3", callback_data: "mb:codex:o3" },
+      { text: "o4-mini", callback_data: "mb:codex:o4-mini" },
+    ]);
+  }
+  rows.push([{ text: `Default (Claude: ${DEFAULT_CLAUDE_MODEL})`, callback_data: "m:default" }]);
+  const beLabel = settings.backend === "cursor" ? "Cursor" : settings.backend === "codex" ? "Codex" : "Claude";
+  return { rows, beLabel, model: settings.model };
+}
+
 register({
   name: "model", description: "Switch model (opus/sonnet/haiku)", args: "[<model>]",
   handler: async (env, { tail }) => {
@@ -569,48 +667,8 @@ register({
       if (settings.model === "default") settings.model = null;
       return send(`Model: ${settings.model || "default"}`);
     }
-    const { settings } = currentState();
-    const rows = [];
-    rows.push([{ text: "── Claude ──", callback_data: "noop" }]);
-    rows.push([
-      { text: "Fable 5", callback_data: "mb:claude:claude-fable-5" },
-      { text: "Opus 4.8", callback_data: "mb:claude:claude-opus-4-8" },
-    ]);
-    rows.push([
-      { text: "Opus 4.7", callback_data: "mb:claude:claude-opus-4-7" },
-      { text: "Opus 4.6", callback_data: "mb:claude:claude-opus-4-6" },
-    ]);
-    rows.push([
-      { text: "Sonnet 4.6", callback_data: "mb:claude:claude-sonnet-4-6" },
-      { text: "Haiku", callback_data: "mb:claude:claude-haiku-4-5-20251001" },
-    ]);
-    if (resolvedCursorPath) {
-      rows.push([{ text: "── Cursor ──", callback_data: "noop" }]);
-      rows.push([
-        { text: "Composer 2", callback_data: "mb:cursor:composer-2" },
-        { text: "Composer 2 Fast", callback_data: "mb:cursor:composer-2-fast" },
-        { text: "Auto", callback_data: "mb:cursor:auto" },
-      ]);
-      rows.push([
-        { text: "Opus 4.6 Thinking", callback_data: "mb:cursor:claude-4.6-opus-high-thinking" },
-        { text: "GPT-5.4", callback_data: "mb:cursor:gpt-5.4-medium" },
-      ]);
-    }
-    if (resolvedCodexPath) {
-      rows.push([{ text: "── Codex ──", callback_data: "noop" }]);
-      rows.push([
-        { text: "GPT-5.5", callback_data: "mb:codex:gpt-5.5" },
-        { text: "gpt-5", callback_data: "mb:codex:gpt-5" },
-        { text: "gpt-5-codex", callback_data: "mb:codex:gpt-5-codex" },
-      ]);
-      rows.push([
-        { text: "o3", callback_data: "mb:codex:o3" },
-        { text: "o4-mini", callback_data: "mb:codex:o4-mini" },
-      ]);
-    }
-    rows.push([{ text: `Default (Claude: ${DEFAULT_CLAUDE_MODEL})`, callback_data: "m:default" }]);
-    const beLabel = settings.backend === "cursor" ? "Cursor" : settings.backend === "codex" ? "Codex" : "Claude";
-    send(`Current: ${beLabel} · ${settings.model || "default"}\n\nPick a model — backend switches automatically.\nOr type /model <name>.`, { keyboard: { inline_keyboard: rows } });
+    const { rows, beLabel, model } = buildModelPicker();
+    send(`Current: ${beLabel} · ${model || "default"}\n\nPick a model — backend switches automatically.\nOr type /model <name>.`, { keyboard: { inline_keyboard: rows } });
   },
 });
 
@@ -1102,10 +1160,12 @@ register({
 });
 
 register({
-  name: "login", description: "Start Claude Code login", ownerOnly: true,
+  name: "login", description: "Pick a model and connect its provider", ownerOnly: true,
   handler: async (env) => {
-    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
-    await runClaudeAuthCommand(["auth", "login", "--claudeai", "--email", "sumeet@inet.africa"], "Claude login");
+    if (!ownerEnv(env)) return send("Owner only — provider auth is shared across users.");
+    await send("Connecting… checking which providers are signed in.");
+    const { rows, beLabel, model } = buildModelPicker({ authAware: true });
+    send(`Current: ${beLabel} · ${model || "default"}\n\nPick a model. If its provider isn't connected yet, tapping it starts the login flow — then you're on that model.`, { keyboard: { inline_keyboard: rows } });
   },
 });
 

package/core/pack-guard.js

@@ -29,8 +29,15 @@ const OVERRIDE_PATTERNS = [
 // Exfiltration: a send/post/upload verb pointed at a URL or address. Scanned in
 // every section, including Journal.
 const EXFIL_PATTERNS = [
-  /\b(send|post|upload|exfiltrate|forward|transmit|leak|email|curl|wget|fetch)\b[^.\n]{0,60}\b(to|at|into)\b[^.\n]{0,40}(https?:\/\/|ftp:\/\/|[\w.-]+@[\w.-]+)/i,
-  /\b(https?:\/\/)[^\s)]+[^\s)]*\b.*\b(api\s*key|token|password|secret|credential|env)/i,
+  // A send/store/upload verb pointed at a URL or address.
+  /\b(send|post|upload|exfiltrate|forward|transmit|leak|email|curl|wget|fetch|store|save|drop|put|copy)\b[^.\n]{0,60}\b(to|at|into)\b[^.\n]{0,40}(https?:\/\/|ftp:\/\/|[\w.-]+@[\w.-]+)/i,
+  // A credential embedded directly in a URL as a query/fragment param
+  // (e.g. https://evil/?token=…): the classic verbless exfil carrier. Prose that
+  // merely mentions a URL near the word "token" no longer trips — the credential
+  // must actually be attached to the URL with =/:, which legitimate infra/ops
+  // notes don't do. This replaces a broad URL+keyword co-occurrence rule that
+  // false-positived on benign sentences like "the API at <url> uses a token".
+  /(https?:\/\/)[^\s)]*?\b(api_?key|access_?token|token|password|secret|credential)\b\s*[=:]/i,
   /\bcurl\b[^\n]*\b(https?:\/\/)/i,
 ];
 

package/core/router.js

@@ -228,10 +228,17 @@ async function handleText(envelope) {
   if (state.pendingClaudeAuthProcess && state.pendingClaudeAuthLabel !== "manual OAuth token save") {
     const text = (envelope.text || "").trim();
     if (looksLikeClaudeAuthReply(text)) {
-      await send("That looks like a Claude login code/callback. I did not delete it or send it to Claude as a prompt. Please resend it as `/auth_code YOUR_CODE`, or use /cancel_auth to stop the login flow.");
+      await deleteMessage(envelope.messageId);
+      try {
+        state.pendingClaudeAuthProcess.stdin.write(text + "\n");
+        await send("Got it — sent the code to Claude. I'll confirm with an auth-status check when it finishes.");
+      } catch (e) {
+        clearPendingClaudeAuth(state);
+        await send(`Could not send the auth code to Claude: ${redactSensitive(e.message)}`);
+      }
       return;
     }
-    await send("Claude login is still waiting. I will not delete normal messages. If Claude gave you a code, send it as `/auth_code YOUR_CODE`, or use /cancel_auth.");
+    await send("Claude login is still waiting. Paste the code/callback Claude gave you and I'll submit it, or send /cancel_auth to stop.");
   }
 
   if (!isOnboarded() && state.onboardingStep) {

package/core/web-auth.js

@@ -0,0 +1,160 @@
+// Web-driven Claude/Codex authentication. Runs the same interactive CLIs
+// the Telegram /login flow uses, but captures the URL/output into in-memory
+// state that the web dashboard polls, instead of pushing it to a chat.
+// A single admin owns the dashboard, so one module-level slot per provider
+// is enough. Lives in-process with the bot (web.js is started by bot.js).
+
+const { spawn } = require("child_process");
+const os = require("os");
+const { CLAUDE_PATH, resolvedCodexPath, botSubprocessEnv } = require("./config");
+const { redactSensitive, stripTerminalControls, extractUrls } = require("./redact");
+const {
+  claudeSubprocessEnv, saveClaudeOAuthToken, getClaudeOAuthToken,
+  extractClaudeToken, isClaudeAuthUrl, looksLikeClaudeToken, looksLikeOpenAIKey,
+  runClaudeAuthStatusDiagnostic, isClaudeAuthErrorText,
+  runCodexLoginStatus, saveCodexApiKeyWithCli,
+} = require("./auth-flow");
+
+const HOME = process.env.HOME || os.homedir();
+
+// ── Claude interactive browser login ────────────────────────────────
+let claude = null;
+
+function startClaudeLogin() {
+  if (claude && claude.proc && !claude.done) return { ok: true, already: true };
+  const proc = spawn(CLAUDE_PATH, ["auth", "login", "--claudeai"], {
+    cwd: HOME, env: claudeSubprocessEnv(), stdio: ["pipe", "pipe", "pipe"],
+  });
+  claude = { proc, url: null, log: "", awaitingCode: false, done: false, ok: false, error: null, tokenStored: false };
+  const onChunk = (buf) => {
+    const chunk = buf.toString();
+    claude.log = (claude.log + chunk).slice(-4000);
+    const token = extractClaudeToken(chunk) || extractClaudeToken(claude.log);
+    if (token && !claude.tokenStored) claude.tokenStored = saveClaudeOAuthToken(token);
+    for (const u of extractUrls(chunk)) {
+      if (isClaudeAuthUrl(u) && !claude.url) { claude.url = u; claude.awaitingCode = true; }
+    }
+  };
+  proc.stdout.on("data", onChunk);
+  proc.stderr.on("data", onChunk);
+  proc.on("close", (code) => {
+    claude.done = true;
+    claude.awaitingCode = false;
+    const tty = /raw mode is not supported|process\.stdin|not a tty|inappropriate ioctl/i.test(claude.log);
+    claude.ok = claude.tokenStored || code === 0;
+    if (!claude.ok) claude.error = tty ? "tty" : "failed";
+  });
+  proc.on("error", (err) => { claude.done = true; claude.ok = false; claude.error = redactSensitive(err.message); });
+  return { ok: true };
+}
+
+function submitClaudeCode(code) {
+  if (!claude || !claude.proc || claude.done) return { ok: false, error: "No Claude login is in progress." };
+  try {
+    claude.proc.stdin.write(String(code || "").trim() + "\n");
+    claude.awaitingCode = false;
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: redactSensitive(e.message) };
+  }
+}
+
+function cancelClaude() {
+  if (claude && claude.proc && claude.proc.kill) { try { claude.proc.kill("SIGTERM"); } catch (e) {} }
+  claude = null;
+  return { ok: true };
+}
+
+function claudeState() {
+  if (!claude) return { running: false };
+  return {
+    running: !claude.done,
+    url: claude.url,
+    awaitingCode: claude.awaitingCode,
+    done: claude.done,
+    ok: claude.ok,
+    error: claude.error,
+    log: redactSensitive(stripTerminalControls(claude.log)).slice(-600),
+  };
+}
+
+// Reliable path: save a pasted Claude OAuth token directly.
+function saveClaudeToken(token) {
+  const t = String(token || "").trim();
+  if (!looksLikeClaudeToken(t)) return { ok: false, error: "That does not look like a Claude OAuth token." };
+  return saveClaudeOAuthToken(t) ? { ok: true } : { ok: false, error: "Could not store the token." };
+}
+
+// ── Codex device login ──────────────────────────────────────────────
+let codex = null;
+
+function startCodexLogin() {
+  if (!resolvedCodexPath) return { ok: false, error: "Codex CLI not found." };
+  if (codex && codex.proc && !codex.done) return { ok: true, already: true };
+  const proc = spawn(resolvedCodexPath, ["login", "--device-auth"], {
+    cwd: HOME, env: botSubprocessEnv(), stdio: ["pipe", "pipe", "pipe"],
+  });
+  codex = { proc, url: null, code: null, log: "", done: false, ok: false, error: null };
+  const onChunk = (buf) => {
+    const clean = redactSensitive(stripTerminalControls(buf.toString()));
+    codex.log = (codex.log + clean).slice(-4000);
+    for (const u of extractUrls(clean)) { if (!codex.url) codex.url = u; }
+    const m = clean.match(/(?:code|device code)[:\s]+([A-Z0-9-]{6,})/i);
+    if (m && !codex.code) codex.code = m[1];
+  };
+  proc.stdout.on("data", onChunk);
+  proc.stderr.on("data", onChunk);
+  proc.on("close", (code) => {
+    codex.done = true;
+    const tty = /raw mode is not supported|not a tty|inappropriate ioctl/i.test(codex.log);
+    codex.ok = code === 0;
+    if (!codex.ok) codex.error = tty ? "tty" : "failed";
+  });
+  proc.on("error", (err) => { codex.done = true; codex.ok = false; codex.error = redactSensitive(err.message); });
+  return { ok: true };
+}
+
+function cancelCodex() {
+  if (codex && codex.proc && codex.proc.kill) { try { codex.proc.kill("SIGTERM"); } catch (e) {} }
+  codex = null;
+  return { ok: true };
+}
+
+function codexState() {
+  if (!codex) return { running: false };
+  return {
+    running: !codex.done,
+    url: codex.url,
+    code: codex.code,
+    done: codex.done,
+    ok: codex.ok,
+    error: codex.error,
+    log: codex.log.slice(-600),
+  };
+}
+
+// Reliable path: save a pasted OpenAI API key via the Codex CLI.
+async function saveCodexApiKey(key) {
+  if (!resolvedCodexPath) return { ok: false, error: "Codex CLI not found." };
+  const k = String(key || "").trim();
+  if (!looksLikeOpenAIKey(k)) return { ok: false, error: "That does not look like an OpenAI API key." };
+  const result = await saveCodexApiKeyWithCli(k);
+  return result.ok ? { ok: true } : { ok: false, error: redactSensitive(result.output).slice(-300) };
+}
+
+// ── Combined status ─────────────────────────────────────────────────
+function authStatus() {
+  const tokenInfo = getClaudeOAuthToken();
+  const diag = runClaudeAuthStatusDiagnostic();
+  const codexStatus = resolvedCodexPath ? runCodexLoginStatus() : { ok: false };
+  return {
+    claude: { configured: !!tokenInfo.value, source: tokenInfo.source, loggedIn: !isClaudeAuthErrorText(diag) },
+    codex: { cliFound: !!resolvedCodexPath, loggedIn: !!codexStatus.ok },
+  };
+}
+
+module.exports = {
+  startClaudeLogin, submitClaudeCode, cancelClaude, claudeState, saveClaudeToken,
+  startCodexLogin, cancelCodex, codexState, saveCodexApiKey,
+  authStatus,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.29",
+  "version": "2.6.31",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {

package/web.js

@@ -15,6 +15,7 @@ const ENV_FILE = path.join(CONFIG_DIR, ".env");
 const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
 const SOUL_FILE = path.join(CONFIG_DIR, "soul.md");
 const CRONS_FILE = path.join(CONFIG_DIR, "crons.json");
+const JOBS_FILE = path.join(CONFIG_DIR, "jobs.json");
 const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
 const WEB_PASSWORD_FILE = path.join(CONFIG_DIR, ".web-password");
 const PORT = parseInt(process.env.WEB_PORT || "8080", 10);
@@ -173,6 +174,13 @@ function loadSoul() {
 }
 
 function loadCrons() {
+  // Crons now live in the unified jobs store (jobs.json), tagged kind:"cron".
+  // The legacy crons.json was migrated and renamed, so read jobs first and
+  // only fall back to the old file for un-migrated installs.
+  try {
+    const jobs = JSON.parse(fs.readFileSync(JOBS_FILE, "utf-8"));
+    if (Array.isArray(jobs)) return jobs.filter((j) => j && j.kind === "cron");
+  } catch (e) { /* fall through to legacy */ }
   try { return JSON.parse(fs.readFileSync(CRONS_FILE, "utf-8")); } catch (e) { return []; }
 }
 
@@ -261,6 +269,24 @@ async function handleAPI(req, res, body) {
     return res.end(JSON.stringify({ error: "Unauthorized" }));
   }
 
+  // ── Authentication (Claude / Codex) ──
+  if (url.startsWith("/api/auth/")) {
+    const webAuth = require("./core/web-auth");
+    const json = (obj, c = 200) => { res.writeHead(c, { "Content-Type": "application/json" }); return res.end(JSON.stringify(obj)); };
+    const post = req.method === "POST";
+    if (url === "/api/auth/status") return json(webAuth.authStatus());
+    if (url === "/api/auth/claude/start" && post) return json(webAuth.startClaudeLogin());
+    if (url === "/api/auth/claude/state") return json(webAuth.claudeState());
+    if (url === "/api/auth/claude/code" && post) return json(webAuth.submitClaudeCode(JSON.parse(body || "{}").code));
+    if (url === "/api/auth/claude/token" && post) return json(webAuth.saveClaudeToken(JSON.parse(body || "{}").token));
+    if (url === "/api/auth/claude/cancel" && post) return json(webAuth.cancelClaude());
+    if (url === "/api/auth/codex/start" && post) return json(webAuth.startCodexLogin());
+    if (url === "/api/auth/codex/state") return json(webAuth.codexState());
+    if (url === "/api/auth/codex/key" && post) return json(await webAuth.saveCodexApiKey(JSON.parse(body || "{}").key));
+    if (url === "/api/auth/codex/cancel" && post) return json(webAuth.cancelCodex());
+    return json({ error: "Unknown auth route" }, 404);
+  }
+
   // Status
   if (url === "/api/status") {
     const env = loadEnv();
@@ -489,13 +515,30 @@ async function handleAPI(req, res, body) {
 
 // ── HTML UI ────────────────────────────────────────────────────────
 
+// The dashboard is generic "Open Claudia" by default, but each pod is its
+// own named bot (e.g. euvy). Prefer an explicit BOT_NAME, else derive the
+// pod name from its public hostname, else fall back to the generic brand.
+function botDisplayName() {
+  if (process.env.BOT_NAME && process.env.BOT_NAME.trim()) return process.env.BOT_NAME.trim();
+  try {
+    const u = process.env.WEB_PUBLIC_URL;
+    if (u) {
+      const host = new URL(u).hostname;
+      const label = host.split(".")[0];
+      if (label) return label;
+    }
+  } catch (e) { /* ignore */ }
+  return "Open Claudia";
+}
+
 function getHTML() {
+  const botName = botDisplayName();
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>Open Claudia</title>
+<title>${botName}</title>
 <style>
   * { margin: 0; padding: 0; box-sizing: border-box; }
   body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f0f0f; color: #e0e0e0; min-height: 100vh; }
@@ -570,7 +613,7 @@ async function init() {
 function showLogin() {
   $("#app").innerHTML = \`
     <div class="login-page"><div class="login-box">
-      <h1>Open Claudia</h1>
+      <h1>${botName}</h1>
       <p class="subtitle">Enter your admin password</p>
       <div id="login-msg"></div>
       <div class="card">
@@ -625,6 +668,7 @@ function render() {
     { id: "dashboard", label: "Dashboard" },
     { id: "usage", label: "Usage" },
     { id: "auth", label: "Users" },
+    { id: "credentials", label: "Credentials" },
     { id: "soul", label: "Soul" },
     { id: "crons", label: "Crons" },
     { id: "sessions", label: "Sessions" },
@@ -637,7 +681,7 @@ function render() {
   }
   $("#app").innerHTML = \`
     <div class="container">
-      <h1>Open Claudia</h1>
+      <h1>${botName}</h1>
       <p class="subtitle">v\${status.version}</p>
       <div class="tabs">
         \${tabs.map(t => \`<div class="tab \${currentTab===t.id?'active':''}" onclick="switchTab('\${t.id}')">\${t.label}</div>\`).join("")}
@@ -724,6 +768,34 @@ async function loadTab() {
           </div>\`).join("")}
       </div>\` : ""}\`;
   }
+  else if (currentTab === "credentials") {
+    el.innerHTML = \`
+      <div class="card" id="cred-status"><h2>Credentials</h2><p class="subtitle">Loading status…</p></div>
+      <div class="card">
+        <h2>Claude</h2>
+        <button onclick="startClaudeAuth()">Authenticate via browser</button>
+        <div id="claude-flow" style="margin-top:12px;"></div>
+        <div style="margin-top:16px;border-top:1px solid #2a2a2a;padding-top:16px;">
+          <label>Or paste a Claude OAuth token</label>
+          <div style="color:#777;font-size:11px;margin:2px 0 6px;">Generate with <code>claude setup-token</code> in a terminal if the browser flow can't finish here.</div>
+          <input id="claude-token" type="password" placeholder="sk-ant-...">
+          <button onclick="saveClaudeTokenWeb()" style="margin-top:8px;">Save token</button>
+          <span id="claude-token-msg" style="margin-left:10px;font-size:12px;color:#888;"></span>
+        </div>
+      </div>
+      <div class="card">
+        <h2>Codex</h2>
+        <button onclick="startCodexAuth()">Authenticate via device</button>
+        <div id="codex-flow" style="margin-top:12px;"></div>
+        <div style="margin-top:16px;border-top:1px solid #2a2a2a;padding-top:16px;">
+          <label>Or paste an OpenAI API key</label>
+          <input id="codex-key" type="password" placeholder="sk-...">
+          <button onclick="saveCodexKeyWeb()" style="margin-top:8px;">Save key</button>
+          <span id="codex-key-msg" style="margin-left:10px;font-size:12px;color:#888;"></span>
+        </div>
+      </div>\`;
+    loadCredStatus();
+  }
   else if (currentTab === "soul") {
     const soul = await api("/api/soul");
     if (!soul) return;
@@ -789,23 +861,44 @@ async function loadTab() {
       </div>
       <div class="card">
         <h2>Configuration</h2>
-        <p style="color:#888;font-size:13px;margin-bottom:12px;">Edit ~/.open-claudia/.env values</p>
+        <p style="color:#888;font-size:13px;margin-bottom:16px;">Changes are saved to the bot's environment and take effect after the next restart.</p>
         <div id="config-fields"></div>
         <button onclick="saveConfig()">Save</button>
         <span id="config-msg" style="margin-left:12px;font-size:13px;color:#888;"></span>
       </div>\`;
     const config = await api("/api/config");
     if (!config) return;
-    const safe = [
-      "WORKSPACE", "CLAUDE_PATH", "WHISPER_CLI", "FFMPEG", "WHISPER_MODEL",
-      "MEMORY_RECALL_MAX_CHARS",
-      "USAGE_ALERT_CONTEXT_TOKENS", "USAGE_ALERT_RATE_MULTIPLIER",
-      "USAGE_ALERT_BASELINE_TURNS", "USAGE_ALERT_MIN_BASELINE_TURNS",
-      "USAGE_ALERT_COOLDOWN_MS",
+    const groups = [
+      { title: "General", fields: [
+        { k: "WORKSPACE", label: "Workspace folder", desc: "Root directory where the bot reads and writes project files.", ph: "/data/Workspace" },
+        { k: "CLAUDE_PATH", label: "Claude CLI path", desc: "Path or command name for the Claude Code CLI.", ph: "claude" },
+      ]},
+      { title: "Voice transcription", fields: [
+        { k: "WHISPER_CLI", label: "Whisper CLI", desc: "Path to the whisper binary for transcribing voice notes. Leave blank to disable voice.", ph: "whisper" },
+        { k: "FFMPEG", label: "ffmpeg path", desc: "Path to ffmpeg, used to convert incoming voice audio.", ph: "ffmpeg" },
+        { k: "WHISPER_MODEL", label: "Whisper model", desc: "Transcription model size, e.g. base / small / medium.", ph: "base" },
+      ]},
+      { title: "Memory", fields: [
+        { k: "MEMORY_RECALL_MAX_CHARS", label: "Memory recall limit", desc: "Max characters of memory injected into context per turn.", ph: "e.g. 6000" },
+      ]},
+      { title: "Usage alerts (advanced)", fields: [
+        { k: "USAGE_ALERT_CONTEXT_TOKENS", label: "Context-token threshold", desc: "Warn when a turn's context exceeds this many tokens.", ph: "e.g. 150000" },
+        { k: "USAGE_ALERT_RATE_MULTIPLIER", label: "Rate multiplier", desc: "Warn when usage exceeds the recent baseline by this factor.", ph: "e.g. 2" },
+        { k: "USAGE_ALERT_BASELINE_TURNS", label: "Baseline window (turns)", desc: "How many recent turns form the usage baseline.", ph: "e.g. 20" },
+        { k: "USAGE_ALERT_MIN_BASELINE_TURNS", label: "Min baseline turns", desc: "Minimum turns required before alerts activate.", ph: "e.g. 5" },
+        { k: "USAGE_ALERT_COOLDOWN_MS", label: "Alert cooldown (ms)", desc: "Minimum gap between repeated usage alerts.", ph: "e.g. 300000" },
+      ]},
     ];
-    $("#config-fields").innerHTML = safe.map(k => \`
-      <div class="form-group"><label>\${k}</label><input id="cfg-\${k}" value="\${config[k] || ""}"></div>
-    \`).join("");
+    $("#config-fields").innerHTML = groups.map(g => \`
+      <div style="margin-bottom:20px;">
+        <div style="font-size:12px;font-weight:600;text-transform:uppercase;letter-spacing:0.5px;color:#9a9aff;border-bottom:1px solid #2a2a2a;padding-bottom:6px;margin-bottom:12px;">\${g.title}</div>
+        \${g.fields.map(f => \`
+          <div class="form-group">
+            <label>\${f.label}</label>
+            <div style="color:#777;font-size:11px;margin:2px 0 6px;">\${f.desc}</div>
+            <input id="cfg-\${f.k}" value="\${config[f.k] || ""}" placeholder="\${f.ph || ""}">
+          </div>\`).join("")}
+      </div>\`).join("");
   }
 }
 
@@ -878,6 +971,88 @@ async function removeAuth(chatId) { await api("/api/auth/remove", { method: "POS
 async function approveAuth(chatId) { await api("/api/auth/approve", { method: "POST", body: { chatId } }); loadTab(); }
 async function denyAuth(chatId) { await api("/api/auth/deny", { method: "POST", body: { chatId } }); loadTab(); }
 
+async function loadCredStatus() {
+  const s = await api("/api/auth/status");
+  if (!s) return;
+  const yn = (b) => b ? "<span style='color:#22c55e'>yes</span>" : "<span style='color:#dc2626'>no</span>";
+  $("#cred-status").innerHTML = \`<h2>Credentials</h2>
+    <div class="list-item"><span>Claude OAuth token saved</span><span>\${yn(s.claude.configured)}</span></div>
+    <div class="list-item"><span>Claude logged in</span><span>\${yn(s.claude.loggedIn)}</span></div>
+    <div class="list-item"><span>Codex CLI present</span><span>\${yn(s.codex.cliFound)}</span></div>
+    <div class="list-item"><span>Codex logged in</span><span>\${yn(s.codex.loggedIn)}</span></div>\`;
+}
+async function startClaudeAuth() {
+  $("#claude-flow").innerHTML = "<p class='subtitle'>Starting…</p>";
+  await api("/api/auth/claude/start", { method: "POST" });
+  pollClaudeAuth();
+}
+async function pollClaudeAuth() {
+  const st = await api("/api/auth/claude/state");
+  if (!st) return;
+  const box = $("#claude-flow");
+  if (st.done) {
+    box.innerHTML = st.ok ? "<div class='msg ok'>Claude authenticated.</div>"
+      : (st.error === "tty" ? "<div class='msg err'>The Claude CLI needs a real terminal here. Paste an OAuth token below instead.</div>"
+      : "<div class='msg err'>Login didn't complete. Paste a token below instead.</div>");
+    loadCredStatus();
+    return;
+  }
+  if (st.url) {
+    box.innerHTML = \`<p style="font-size:13px;">Open this URL, sign in, then paste the code Claude gives you:</p>
+      <p style="word-break:break-all;"><a href="\${st.url}" target="_blank">\${st.url}</a></p>
+      <input id="claude-code" placeholder="Paste code here">
+      <button onclick="submitClaudeCodeWeb()" style="margin-top:8px;">Submit code</button>\`;
+  } else {
+    box.innerHTML = "<p class='subtitle'>Starting…</p>";
+  }
+  setTimeout(pollClaudeAuth, 2000);
+}
+async function submitClaudeCodeWeb() {
+  const code = $("#claude-code").value;
+  await api("/api/auth/claude/code", { method: "POST", body: { code } });
+  $("#claude-flow").innerHTML = "<p class='subtitle'>Submitting…</p>";
+  setTimeout(pollClaudeAuth, 1500);
+}
+async function saveClaudeTokenWeb() {
+  const token = $("#claude-token").value;
+  const r = await api("/api/auth/claude/token", { method: "POST", body: { token } });
+  $("#claude-token-msg").textContent = r && r.ok ? "Saved — restart to apply." : ((r && r.error) || "Failed");
+  if (r && r.ok) { $("#claude-token").value = ""; loadCredStatus(); }
+}
+async function startCodexAuth() {
+  $("#codex-flow").innerHTML = "<p class='subtitle'>Starting…</p>";
+  const r = await api("/api/auth/codex/start", { method: "POST" });
+  if (r && r.error) { $("#codex-flow").innerHTML = "<div class='msg err'>" + r.error + "</div>"; return; }
+  pollCodexAuth();
+}
+async function pollCodexAuth() {
+  const st = await api("/api/auth/codex/state");
+  if (!st) return;
+  const box = $("#codex-flow");
+  if (st.done) {
+    box.innerHTML = st.ok ? "<div class='msg ok'>Codex authenticated.</div>"
+      : (st.error === "tty" ? "<div class='msg err'>The Codex CLI needs a real terminal here. Paste an API key below instead.</div>"
+      : "<div class='msg err'>Login didn't complete. Paste an API key below instead.</div>");
+    loadCredStatus();
+    return;
+  }
+  if (st.url) {
+    box.innerHTML = \`<p style="font-size:13px;">Open this URL and enter the code:</p>
+      <p style="word-break:break-all;"><a href="\${st.url}" target="_blank">\${st.url}</a></p>
+      \${st.code ? "<p>Device code: <b>" + st.code + "</b></p>" : ""}
+      <p class='subtitle'>Waiting for you to finish in the browser…</p>\`;
+  } else {
+    box.innerHTML = "<p class='subtitle'>Starting…</p>";
+  }
+  setTimeout(pollCodexAuth, 2000);
+}
+async function saveCodexKeyWeb() {
+  const key = $("#codex-key").value;
+  const r = await api("/api/auth/codex/key", { method: "POST", body: { key } });
+  $("#codex-key-msg").textContent = r && r.ok ? "Saved." : ((r && r.error) || "Failed");
+  if (r && r.ok) { $("#codex-key").value = ""; loadCredStatus(); }
+}
+
 async function saveSoul() {
   await api("/api/soul", { method: "POST", body: { content: $("#soul-content").value } });
   $("#soul-msg").textContent = "Saved";
@@ -903,7 +1078,7 @@ async function saveConfig() {
 function renderSetup() {
   $("#app").innerHTML = \`
     <div class="container">
-      <h1>Open Claudia Setup</h1>
+      <h1>${botName} Setup</h1>
       <p class="subtitle">Configure your AI coding assistant</p>
       <div id="setup-msg"></div>
       <div class="card">