@inetafrica/open-claudia 3.0.44 → 3.1.1

package/core/doctor-memory.js

@@ -0,0 +1,213 @@
+// Memory-substrate health checks for /doctor. These are the tripwires that
+// would have caught the node-20 pod outage: node:sqlite silently absent, so
+// recall ran 542 turns over 16 days with zero seeds and 87% of reviewer runs
+// lost their mutations — and nothing surfaced it. Every check is synchronous,
+// fast, never throws, and never spawns a model.
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const METRICS_TAIL_BYTES = 256 * 1024;
+const LOCK_HELD_WARN_MS = 5 * 60 * 1000;
+const DISK_WARN_BYTES = 1024 * 1024 * 1024;
+const DISK_FAIL_BYTES = 200 * 1024 * 1024;
+
+function sqliteAvailable() {
+  try { require("node:sqlite"); return true; } catch (_) { return false; }
+}
+
+// Last ~N bytes of a JSONL file as parsed objects (partial first line dropped).
+function tailJsonl(file, maxBytes = METRICS_TAIL_BYTES) {
+  let fd = null;
+  try {
+    const stat = fs.statSync(file);
+    fd = fs.openSync(file, "r");
+    const size = Math.min(stat.size, maxBytes);
+    const buf = Buffer.alloc(size);
+    fs.readSync(fd, buf, 0, size, stat.size - size);
+    const lines = buf.toString("utf-8").split("\n").filter(Boolean);
+    if (stat.size > maxBytes) lines.shift();
+    return lines.map((l) => { try { return JSON.parse(l); } catch (_) { return null; } }).filter(Boolean);
+  } catch (_) {
+    return [];
+  } finally {
+    if (fd !== null) { try { fs.closeSync(fd); } catch (_) {} }
+  }
+}
+
+function substrateCheck() {
+  if (sqliteAvailable()) {
+    return { ok: true, label: "Memory substrate (node:sqlite)", detail: "available — FTS matching, recall graph, episodic index active" };
+  }
+  return {
+    ok: false,
+    label: "Memory substrate (node:sqlite)",
+    detail: `missing on Node ${process.version} — recall graph, FTS and episodic memory DISABLED; lexical keyword fallback only`,
+    action: "Run on Node 24+ (Dockerfile.base must build FROM node:24-slim). Memory stays degraded until then.",
+  };
+}
+
+function graphCheck() {
+  if (!sqliteAvailable()) return null; // substrate check already reports the cause
+  try {
+    const graph = require("./recall/graph");
+    if (!graph.available()) {
+      return { ok: true, warn: true, label: "Recall graph", detail: "unavailable", action: "Graph module failed to open its database — check RECALL_GRAPH_DB path/permissions." };
+    }
+    const s = graph.stats();
+    return { ok: true, label: "Recall graph", detail: `${s.nodes} nodes, ${s.edges} edges` };
+  } catch (e) {
+    return { ok: true, warn: true, label: "Recall graph", detail: `check failed: ${e.message}` };
+  }
+}
+
+function recallPipelineCheck(now = Date.now()) {
+  const label = "Recall pipeline (24h)";
+  try {
+    const metrics = require("./recall/metrics");
+    const cutoff = now - DAY_MS;
+    const lines = tailJsonl(metrics.LOG_FILE);
+    const turns = lines.filter((r) => r.engine && Date.parse(r.ts || "") >= cutoff);
+    const live = turns.filter((r) => !r.gated);
+    if (!live.length) {
+      return { ok: true, warn: true, label, detail: "no recall turns in the last 24h (idle, or classic engine)" };
+    }
+    const seeded = live.filter((r) => (r.seeds || []).length > 0).length;
+    const injected = live.filter((r) => (r.kept || []).length > 0).length;
+    const walkerFailed = live.filter((r) => r.walker === "failed").length;
+    const detail = `${live.length} turns, ${seeded} seeded, ${injected} injected memories, ${walkerFailed} walker failures`;
+    if (live.length >= 10 && seeded === 0) {
+      return { ok: false, label, detail: `${detail} — matching is returning NOTHING`, action: "Recall is running blind. Check the substrate above and the packs/entities indexes." };
+    }
+    if (live.length >= 10 && injected === 0) {
+      return { ok: true, warn: true, label, detail: `${detail} — nothing injected all day`, action: "Seeds exist but nothing survives to injection — check walker health and the relevance gate." };
+    }
+    return { ok: true, label, detail };
+  } catch (e) {
+    return { ok: true, warn: true, label, detail: `check failed: ${e.message}` };
+  }
+}
+
+function reviewerCheck(now = Date.now()) {
+  const label = "Memory reviewer (24h)";
+  try {
+    const metrics = require("./recall/metrics");
+    const cutoff = now - DAY_MS;
+    const runs = tailJsonl(metrics.LOG_FILE).filter((r) => r.reviewer && Date.parse(r.ts || "") >= cutoff);
+    if (!runs.length) {
+      return { ok: true, warn: true, label, detail: "no reviewer runs in the last 24h" };
+    }
+    const failed = runs.filter((r) => r.reviewer.status === "failed");
+    const deferred = runs.filter((r) => r.reviewer.status === "deferred").length;
+    const lastFail = failed.length ? failed[failed.length - 1].reviewer.code || "" : "";
+    const okRate = (runs.length - failed.length) / runs.length;
+    const detail = `${runs.length} runs, ${failed.length} failed${deferred ? `, ${deferred} deferred` : ""}${lastFail ? ` (last error: ${lastFail})` : ""}`;
+    if (okRate < 0.5) {
+      return { ok: false, label, detail, action: "Most memory captures are being lost — check the mutation lock and pending review mutations below." };
+    }
+    if (okRate < 0.9) {
+      return { ok: true, warn: true, label, detail, action: "Reviewer failure rate is elevated — check the mutation lock below." };
+    }
+    return { ok: true, label, detail };
+  } catch (e) {
+    return { ok: true, warn: true, label, detail: `check failed: ${e.message}` };
+  }
+}
+
+function mutationLockCheck() {
+  const label = "Memory mutation lock";
+  try {
+    const { inspectLock } = require("./memory-mutation-queue");
+    const lock = inspectLock();
+    if (!lock.held) return { ok: true, label, detail: "free" };
+    const mins = Math.round(lock.ageMs / 60000);
+    const holder = lock.owner ? `pid ${lock.owner.pid}${lock.owner.id ? ` (${String(lock.owner.id).slice(0, 8)})` : ""}` : "unknown owner";
+    if (lock.stale) {
+      return { ok: true, warn: true, label, detail: `stale — holder gone (${holder}, ${mins}m old); breaks on next mutation` };
+    }
+    if (lock.ageMs > LOCK_HELD_WARN_MS) {
+      return { ok: true, warn: true, label, detail: `held ${mins}m by live ${holder}`, action: "A dream/review may be wedged holding the lock — if this persists, investigate that process." };
+    }
+    return { ok: true, label, detail: `held by ${holder} (active mutation)` };
+  } catch (e) {
+    return { ok: true, warn: true, label, detail: `check failed: ${e.message}` };
+  }
+}
+
+function deferredMutationsCheck() {
+  const label = "Pending review mutations";
+  try {
+    const { listDeferredDecisions } = require("./pack-review");
+    const pending = listDeferredDecisions();
+    if (!pending.length) return { ok: true, label, detail: "none" };
+    return {
+      ok: true, warn: true, label,
+      detail: `${pending.length} computed decision(s) never applied (lock timeouts)`,
+      action: `Inspect ${path.join(CONFIG_DIR, "pending-review-mutations.jsonl")} — re-apply what still matters, then clear it.`,
+    };
+  } catch (e) {
+    return { ok: true, warn: true, label, detail: `check failed: ${e.message}` };
+  }
+}
+
+function corpusCheck() {
+  const label = "Memory corpus";
+  try {
+    const packs = require("./packs").listPacks().length;
+    const entities = require("./entities").listEntities().length;
+    const lessonsLib = require("./lessons");
+    const lessonCount = lessonsLib.listLessons().length;
+    const overCap = lessonCount > lessonsLib.MAX_LESSONS;
+    return {
+      ok: true,
+      warn: overCap,
+      label,
+      detail: `${packs} packs, ${entities} entities, ${lessonCount}/${lessonsLib.MAX_LESSONS} lessons${overCap ? " (over cap)" : ""}`,
+      action: overCap ? "Lessons exceed the always-loaded cap — run `open-claudia dream` to consolidate." : "",
+    };
+  } catch (e) {
+    return { ok: true, warn: true, label, detail: `check failed: ${e.message}` };
+  }
+}
+
+function diskCheck() {
+  const label = "Disk space (config dir)";
+  if (typeof fs.statfsSync !== "function") return null;
+  try {
+    const s = fs.statfsSync(CONFIG_DIR);
+    const free = Number(s.bsize) * Number(s.bavail);
+    const gb = (free / (1024 * 1024 * 1024)).toFixed(1);
+    if (free < DISK_FAIL_BYTES) {
+      return { ok: false, label, detail: `${gb} GB free`, action: "Nearly out of disk — memory writes will start failing. Free space now." };
+    }
+    if (free < DISK_WARN_BYTES) {
+      return { ok: true, warn: true, label, detail: `${gb} GB free`, action: "Low disk — consider clearing old transcripts/artifacts." };
+    }
+    return { ok: true, label, detail: `${gb} GB free` };
+  } catch (_) {
+    return null;
+  }
+}
+
+// The full memory section, in report order. Never throws.
+function memoryChecks(options = {}) {
+  const now = options.now || Date.now();
+  const checks = [];
+  for (const check of [
+    substrateCheck(),
+    graphCheck(),
+    recallPipelineCheck(now),
+    reviewerCheck(now),
+    mutationLockCheck(),
+    deferredMutationsCheck(),
+    corpusCheck(),
+    diskCheck(),
+  ]) {
+    if (check) checks.push(check);
+  }
+  return checks;
+}
+
+module.exports = { memoryChecks, sqliteAvailable, tailJsonl };

package/core/doctor.js

@@ -160,6 +160,11 @@ function runDoctorChecks(options = {}) {
 
   checks.push(checkWritableDir(WORKSPACE, "Workspace writable"));
   checks.push(checkWritableDir(CONFIG_DIR, "Config dir writable"));
+  try {
+    checks.push(...require("./doctor-memory").memoryChecks());
+  } catch (e) {
+    checks.push({ ok: true, warn: true, label: "Memory health", detail: `checks failed to run: ${redactSensitive(e.message)}` });
+  }
   return checks;
 }
 

package/core/dream.js

@@ -1221,13 +1221,14 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       }
     }
 
-    // Recall-graph maintenance: refresh structural edges, decay reinforced
-    // weights, prune orphans. Deterministic + safe, runs every dream.
+    // Recall-graph maintenance: refresh structural edges, prune orphans.
+    // Weight decay is read-time (graph.effectiveWeight) — nothing to rewrite
+    // nightly. Deterministic + safe, runs every dream.
     let graphNote = "";
     try {
-      const g = recallGraphLib.tend(packs, entities, { halfLifeDays: recallTuning.get("decayHalfLifeDays") });
-      if (g.synced || g.decayed || g.pruned) {
-        graphNote = `🕸 Recall graph: ${g.edges} edges / ${g.nodes} nodes (synced ${g.synced}, decayed ${g.decayed}, pruned ${g.pruned}).`;
+      const g = recallGraphLib.tend(packs, entities);
+      if (g.synced || g.pruned) {
+        graphNote = `🕸 Recall graph: ${g.edges} edges / ${g.nodes} nodes (synced ${g.synced}, pruned ${g.pruned}).`;
       }
     } catch (e) { /* graph is best-effort */ }
 
@@ -1241,8 +1242,9 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       }
     } catch (e) { /* episodic index is best-effort */ }
 
-    // Tool hygiene: tend the directed tool-graph (decay reinforced follows-edges,
-    // prune faded/orphaned ones) and flag tools whose --pack link now dangles.
+    // Tool hygiene: tend the directed tool-graph (prune faded/orphaned
+    // follows-edges — decay itself is read-time) and flag tools whose --pack
+    // link now dangles.
     // Read-only toward the tools themselves — a tool is never auto-deleted (that's
     // destructive); we just surface the breakage for the user to re-link or remove.
     let toolNote = "";
@@ -1258,8 +1260,8 @@ async function runDreamMutation({ trigger = "manual", provider = null, runUtilit
       const capList = (items, sep = ", ", max = 5) => (items.length <= max
         ? items.join(sep)
         : `${items.slice(0, max).join(sep)} …and ${items.length - max} more (full list in the dream log)`);
-      if (tg.edges || tg.decayed || tg.pruned) {
-        push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (decayed ${tg.decayed}, pruned ${tg.pruned}).`);
+      if (tg.edges || tg.pruned) {
+        push(`🔧 Tool graph: ${tg.edges} edges / ${tg.nodes} nodes (pruned ${tg.pruned}).`);
       }
       const allTools = toolsLib.listTools();
       const dangling = allTools.filter((t) => t.pack && !packs.readPack(t.pack));

package/core/entities.js

@@ -264,7 +264,7 @@ let _db = null;
 let _indexedAt = 0;
 let _dirty = true;
 
-function markIndexDirty() { _dirty = true; }
+function markIndexDirty() { _dirty = true; _lexicalDocsAt = -1; }
 
 function openDb() {
   if (!DatabaseSync) return null;
@@ -350,16 +350,60 @@ function queryTerms(text) {
   return terms;
 }
 
+// Pure-JS floor under matchEntities for substrates without node:sqlite —
+// same rationale and scoring as the packs floor. Strong is name+aliases
+// only (description scores as body, mirroring the FTS strong filter).
+function termVariants(t) {
+  for (const suffix of ["ing", "ed", "es", "s"]) {
+    if (t.length > suffix.length + 2 && t.endsWith(suffix)) return [t, t.slice(0, -suffix.length)];
+  }
+  return [t];
+}
+
+let _lexicalDocs = null;
+let _lexicalDocsAt = -1;
+
+function lexicalDocs() {
+  const mtime = latestMtime();
+  if (_lexicalDocs && _lexicalDocsAt === mtime) return _lexicalDocs;
+  _lexicalDocs = listEntities().map((e) => ({
+    slug: e.slug,
+    name: e.name,
+    strong: [e.name, e.aliases.join(" ")].join("\n").toLowerCase(),
+    body: [e.description, e.sections.Notes, e.sections.Log, e.sections.Role, e.sections.Style, e.sections.Knows]
+      .filter(Boolean).join("\n").toLowerCase(),
+  }));
+  _lexicalDocsAt = mtime;
+  return _lexicalDocs;
+}
+
+function matchEntitiesLexical(text, { limit = 4, threshold = null } = {}) {
+  const terms = queryTerms(text);
+  if (terms.length === 0) return [];
+  const minScore = threshold ?? Number(process.env.ENTITY_MATCH_THRESHOLD || 2);
+  const scored = [];
+  for (const doc of lexicalDocs()) {
+    let score = 0;
+    for (const t of terms) {
+      const variants = termVariants(t);
+      if (variants.some((v) => doc.strong.includes(v))) score += 2;
+      else if (variants.some((v) => doc.body.includes(v))) score += 1;
+    }
+    if (score >= minScore) scored.push({ slug: doc.slug, name: doc.name, score });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, Math.max(1, Math.min(10, limit)));
+}
+
 function matchEntities(text, { limit = 4, threshold = null } = {}) {
   const db = openDb();
-  if (!db) return [];
+  if (!db) return matchEntitiesLexical(text, { limit, threshold });
   ensureIndex();
   const terms = queryTerms(text);
   if (terms.length === 0) return [];
   const minScore = threshold ?? Number(process.env.ENTITY_MATCH_THRESHOLD || 2);
   const scores = new Map();
   let stmt;
-  try { stmt = db.prepare("SELECT slug FROM entities WHERE entities MATCH ?"); } catch (e) { return []; }
+  try { stmt = db.prepare("SELECT slug FROM entities WHERE entities MATCH ?"); } catch (e) { return matchEntitiesLexical(text, { limit, threshold }); }
   for (const t of terms) {
     const quoted = `"${t.replace(/"/g, '""')}"`;
     let strong = [];

package/core/handlers.js

@@ -48,6 +48,7 @@ const {
   runClaudeAuthCommand, clearPendingClaudeAuth,
   sendCodexAuthStatusSummary, runCodexDeviceLogin, clearPendingCodexAuth,
   saveCodexApiKeyWithCli,
+  canLogout, providerLogout, providerAccountSummary,
 } = require("./auth-flow");
 const providerRegistry = require("./providers");
 
@@ -375,7 +376,7 @@ register({
       "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",
+      "System: /doctor /requirements /restart /upgrade /downgrade /safemode",
       "",
       "Send text, voice, photos, or files.",
       "Reply to any message for context.",
@@ -693,6 +694,8 @@ register({
       // can be SIGTERM'd at any moment, and an unsent ack dies with us.
       await send("Upgrade requested — AgentSpace will pull latest image and restart, see you in a minute.");
       recordUpgradeRequested();
+      try { require("./boot-health").recordPendingDoctor({ reason: "AgentSpace image rollout", from: CURRENT_VERSION }); } catch (e) {}
+      try { require("./safe-mode").clearCrashLoop(); } catch (e) {}
       try {
         const result = await requestAgentSpaceUpgrade();
         if (result && (result.status === 202 || result.status === 200)) {
@@ -762,6 +765,8 @@ register({
       const tailNote = "Source refreshed in /app. If this release also changed the Dockerfile (apt packages, env, base image), the host still needs a docker pull + recreate for those.";
       const msg = `Installed v${newVersion}.${whatsNew ? `\n\nWhat's new:\n${whatsNew}` : ""}\n\n${tailNote}\n\nRestarting...`;
       await send(msg.length > 3900 ? msg.slice(0, 3900) : msg);
+      try { require("./boot-health").recordPendingDoctor({ reason: "source overlay upgrade", from: CURRENT_VERSION, to: newVersion }); } catch (e) {}
+      try { require("./safe-mode").clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /upgrade → v${newVersion} (source refresh)`, { code: 0 }); } catch (e) {}
       setTimeout(() => process.exit(0), 2000);
       return;
@@ -810,6 +815,8 @@ register({
       const doctorReport = formatDoctorReport(runDoctorChecks());
       const msg = `Installed v${newPkg.version}.${whatsNew ? `\n\nWhat's new:\n${whatsNew}` : ""}\n\nPost-upgrade requirements check:\n${doctorReport}\n\nGoing offline to restart...`;
       await send(msg.length > 3900 ? msg.slice(0, 3900) : msg);
+      try { require("./boot-health").recordPendingDoctor({ reason: "npm upgrade", from: CURRENT_VERSION, to: newPkg.version }); } catch (e) {}
+      try { require("./safe-mode").clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /upgrade → v${newPkg.version}`, { code: 0 }); } catch (e) {}
     } catch (e) {
       const errOutput = (e.stdout || e.stderr || e.message || "").slice(-500);
@@ -820,6 +827,115 @@ register({
   },
 });
 
+// Roll back to an earlier release. The rescue half of /upgrade: a bad release
+// that crash-loops lands in safe mode, and this is the chat-side way back to
+// a version that worked. No arg ⇒ the previously-running version from boot
+// history. Deliberately skips the AgentSpace control-plane path (it can only
+// pull :latest): on pods this overlays /app in place, which survives restarts
+// but not a pod recreate — the permanent fix there is rolling the image.
+register({
+  name: "downgrade", description: "Roll back to a previous version", args: "[version]", ownerOnly: true,
+  handler: async (env, { args }) => {
+    if (!ownerEnv(env)) return;
+    const safeModeLib = require("./safe-mode");
+    let target = (args[0] || "").trim().replace(/^v/i, "");
+    if (!target) {
+      target = safeModeLib.previousVersion(CURRENT_VERSION);
+      if (!target) {
+        await send("No earlier version in my boot history — tell me one explicitly, e.g. /downgrade 3.0.44");
+        return;
+      }
+    }
+    // The version lands in a shell command: accept strict semver only.
+    if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(target)) {
+      await send(`That doesn't look like a version: "${target}". Use e.g. /downgrade 3.0.44`);
+      return;
+    }
+    if (target === CURRENT_VERSION) {
+      await send(`I'm already on v${CURRENT_VERSION}.`);
+      return;
+    }
+    const execEnv = { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() };
+    let resolved = null;
+    try {
+      resolved = execSync(`npm view @inetafrica/open-claudia@${target} version`, {
+        encoding: "utf-8", timeout: 15000, env: execEnv,
+      }).trim().split("\n").filter(Boolean).pop() || null;
+    } catch (e) {
+      await send(`Could not verify v${target} on npm (${(e.message || String(e)).slice(0, 200)}).`);
+      return;
+    }
+    if (!resolved) {
+      await send(`v${target} does not exist on the npm registry.`);
+      return;
+    }
+    const direction = isNewerVersion(resolved, CURRENT_VERSION) ? "Moving" : "Rolling back";
+    if (isDockerAppLayout()) {
+      try { process.chdir("/tmp"); } catch (e) {}
+      const podNote = process.env.AGENTSPACE_POD_TOKEN
+        ? "\nNote: this is an in-place overlay — a pod recreate returns to the deployment image version. Roll the image for a permanent downgrade."
+        : "";
+      await send(`${direction} v${CURRENT_VERSION} → v${resolved} (in-place tarball overlay into /app)...${podNote}`);
+      try {
+        inPlaceTarballUpgrade(resolved);
+      } catch (e) {
+        const errOutput = (e.stdout || e.stderr || e.message || String(e)).slice(-700);
+        await send(`Downgrade failed:\n${errOutput}`);
+        return;
+      }
+      await send(`Installed v${resolved}. Restarting...`);
+      try { require("./boot-health").recordPendingDoctor({ reason: "downgrade overlay", from: CURRENT_VERSION, to: resolved }); } catch (e) {}
+      try { safeModeLib.clearCrashLoop(); } catch (e) {}
+      try { require("./restart-reason").recordExitReason(`User /downgrade → v${resolved} (source refresh)`, { code: 0 }); } catch (e) {}
+      setTimeout(() => process.exit(0), 2000);
+      return;
+    }
+    try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
+    await send(`${direction} v${CURRENT_VERSION} → v${resolved}...`);
+    try {
+      execSync(`npm install -g @inetafrica/open-claudia@${resolved} 2>&1`, {
+        encoding: "utf-8", timeout: 120000,
+        cwd: process.env.HOME || require("os").homedir(),
+        env: execEnv,
+      });
+      await send(`Installed v${resolved}. Going offline to restart...`);
+      try { require("./boot-health").recordPendingDoctor({ reason: "downgrade", from: CURRENT_VERSION, to: resolved }); } catch (e) {}
+      try { safeModeLib.clearCrashLoop(); } catch (e) {}
+      try { require("./restart-reason").recordExitReason(`User /downgrade → v${resolved}`, { code: 0 }); } catch (e) {}
+    } catch (e) {
+      const errOutput = (e.stdout || e.stderr || e.message || "").slice(-500);
+      await send(`Downgrade failed:\n${errOutput}`);
+      return;
+    }
+    setTimeout(() => process.exit(0), 2000);
+  },
+});
+
+register({
+  name: "safemode", description: "Safe-mode status, or continue past it", args: "[continue]", ownerOnly: true,
+  handler: async (env, { args }) => {
+    if (!ownerEnv(env)) return;
+    const safeModeLib = require("./safe-mode");
+    const sub = (args[0] || "").toLowerCase();
+    if (sub === "continue") {
+      if (!safeModeLib.isSafeMode()) {
+        await send(`Running normally (v${CURRENT_VERSION}) — there's no safe mode to continue past.`);
+        return;
+      }
+      safeModeLib.requestContinue();
+      await send("Override armed: the next boot runs normally even if the substrate is missing (keyword-only memory) and the crash-loop counter resets. Restarting now...");
+      try { require("./restart-reason").recordExitReason("User /safemode continue override", { code: 0 }); } catch (e) {}
+      setTimeout(() => process.exit(0), 1500);
+      return;
+    }
+    if (safeModeLib.isSafeMode()) {
+      await send(safeModeLib.formatSafeModeAlert({ version: CURRENT_VERSION }));
+    } else {
+      await send(`Running normally (v${CURRENT_VERSION}) — safe mode not active.`);
+    }
+  },
+});
+
 register({
   name: "spaces", description: "Control Kazee Spaces auto-replies (status/pause/resume/mode)",
   args: "<status | pause | resume | mode advisory|autonomous|off>", ownerOnly: true,
@@ -971,13 +1087,16 @@ function buildModelPicker({ authAware = false, state = currentState(), registry
   const rows = [];
   for (const provider of registry.listProviders()) {
     let authMarker = "";
+    let connected = false;
     if (authAware) {
-      let connected = false;
       try { connected = provider.authStatus().state === "authenticated"; } catch (_) {}
       authMarker = connected ? " · connected" : " · tap to connect";
     }
     const availableMarker = providerAvailability(provider) ? "" : " · unavailable";
     rows.push([{ text: `── ${provider.label}${availableMarker}${authMarker} ──`, callback_data: "noop" }]);
+    if (authAware && connected && canLogout(provider.id)) {
+      rows.push([{ text: "🔁 Switch account", callback_data: `sw:${provider.id}` }]);
+    }
     const choices = provider.modelChoices();
     for (let index = 0; index < choices.length; index += 3) {
       rows.push(choices.slice(index, index + 3).map((model) => ({
@@ -1488,7 +1607,9 @@ register({
           return `${name === "readOnlyMode" ? "read-only" : name} ${capability.support}`;
         }).join(" · ")
       : "none";
+    const safeModeLib = require("./safe-mode");
     send([
+      ...(safeModeLib.isSafeMode() ? [`⛔ SAFE MODE (${safeModeLib.bootInfo().reasons.join(", ")}) — /safemode for details`] : []),
       `Project: ${state.currentSession?.name || "none"}`,
       `Provider: ${provider?.label || "none"}`,
       `Model: ${settings?.model || provider?.defaultModel() || "default"} | Effort: ${settings?.effort || "default"}`,
@@ -1811,6 +1932,43 @@ register({
   },
 });
 
+async function startProviderLogin(providerId) {
+  if (providerId === "claude") return runClaudeAuthCommand(["auth", "login", "--claudeai"], "Claude login");
+  if (providerId === "codex") return runCodexDeviceLogin();
+  return send(`No login flow for provider "${providerId}".`);
+}
+
+async function performProviderLogout(providerId, { thenLogin = false } = {}) {
+  const provider = providerFromRegistry(providerId);
+  const label = provider ? provider.label : providerId;
+  const result = providerLogout(providerId);
+  await send(`${label} sign-out:\n${result.steps.map((s) => `• ${s}`).join("\n")}`);
+  if (thenLogin) return startProviderLogin(providerId);
+  await send(`Sign in with a different account when ready — tap below or use /login.`, {
+    keyboard: { inline_keyboard: [[{ text: `Sign in ${label}`, callback_data: `li:${providerId}` }]] },
+  });
+}
+
+module.exports.startProviderLogin = startProviderLogin;
+module.exports.performProviderLogout = performProviderLogout;
+
+register({
+  name: "logout", description: "Sign out of a provider (full: CLI store + bot token)", args: "[claude|codex]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — provider auth is shared across users.");
+    const raw = (tail || "").trim().toLowerCase();
+    const target = ({ gpt: "codex", openai: "codex", chatgpt: "codex", anthropic: "claude" })[raw] || raw;
+    if (canLogout(target)) return performProviderLogout(target);
+    if (target) return send(`Unknown provider "${target}". Use /logout claude or /logout codex.`);
+    return send("Sign out of which provider? This clears the CLI credential store (and Claude's bot token) so /login offers a fresh sign-in.", {
+      keyboard: { inline_keyboard: [[
+        { text: "Claude", callback_data: "lo:claude" },
+        { text: "Codex", callback_data: "lo:codex" },
+      ]] },
+    });
+  },
+});
+
 register({
   name: "setup_token", description: "Create Claude OAuth token", ownerOnly: true,
   handler: async (env) => {

package/core/keyring.js

@@ -21,21 +21,41 @@
 const fs = require("fs");
 const path = require("path");
 const CONFIG_DIR = require("../config-dir");
+const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
 
 const KEYRING_FILE = process.env.KEYRING_FILE || path.join(CONFIG_DIR, "keyring.json");
 
+let warnedCorrupt = false;
+
 function load() {
+  let raw;
   try {
-    const data = JSON.parse(fs.readFileSync(KEYRING_FILE, "utf-8"));
+    raw = fs.readFileSync(KEYRING_FILE, "utf-8");
+  } catch (e) {
+    return {}; // no keyring yet — fine
+  }
+  try {
+    const data = JSON.parse(raw);
     return data && typeof data === "object" ? data : {};
   } catch (e) {
-    return {}; // missing or corrupt → empty keyring
+    // File exists but is unparseable: fall back to the last-good .bak snapshot
+    // rather than silently running credential-less, and say so loudly — stderr
+    // reaches the bot log, and from `tool run` it lands in the agent's
+    // transcript so the failure surfaces to the owner instead of vanishing.
+    const data = readJsonWithFallback(KEYRING_FILE, null);
+    if (!warnedCorrupt) {
+      warnedCorrupt = true;
+      console.error(`[keyring] ${KEYRING_FILE} is corrupt (${e.message}); ${
+        data ? "using the last-good .bak snapshot" : "NO usable backup — tools run WITHOUT credentials until it is restored"}.`);
+    }
+    return data && typeof data === "object" ? data : {};
   }
 }
 
 function save(data) {
-  fs.writeFileSync(KEYRING_FILE, JSON.stringify(data, null, 2) + "\n");
-  try { fs.chmodSync(KEYRING_FILE, 0o600); } catch (e) { /* best effort on odd filesystems */ }
+  // Atomic, 0600 from birth (no torn-file window, no chmod-after-write gap),
+  // with a last-good .bak snapshot that load() falls back to on corruption.
+  atomicWriteFileSync(KEYRING_FILE, JSON.stringify(data, null, 2) + "\n", { backup: true, mode: 0o600 });
 }
 
 // Full {key: value} map — used to inject creds into subprocess env.