@inetafrica/open-claudia 3.0.44 → 3.1.0

package/core/recall/graph.js

@@ -12,6 +12,14 @@
 // `weight` and `last_reinforced`. Structural edges (parent/related from pack
 // metadata) are re-derived idempotently; their weight floor is kept but any
 // extra reinforcement earned through use is preserved.
+//
+// Decay is computed ON READ, never rewritten in place ("decay-on-read"): the
+// stored `weight` is the value AS OF `last_reinforced`, and every read maps it
+// through effectiveWeight(). Writes that change a weight (reinforce, weaken)
+// first settle the decay accrued so far, then apply their delta and restamp.
+// The old nightly decay() rewrite reapplied the full age to an already-decayed
+// weight every night (compounding — a 60d half-life emptied in ~10 nights);
+// with no rewrite path, that bug class cannot exist.
 
 const fs = require("fs");
 const path = require("path");
@@ -29,13 +37,14 @@ const EDGE_TYPES = ["parent", "governed-by", "related"];
 // Base weights when an edge is first derived from structure.
 const BASE_WEIGHT = { parent: 3, "governed-by": 2.5, related: 1 };
 // Spreading-activation tunables (overridable via env / dream knobs).
+// The decay half-life lives in tuning.js (`decayHalfLifeDays`, env-pinnable),
+// read lazily so a dream knob change applies to the very next read.
 const DEFAULTS = {
   hops: 2,
   threshold: 0.18,   // firing threshold as a fraction of the strongest seed
   damping: 0.55,     // fraction of activation transmitted per hop
   perNodeTopK: 6,    // cap fan-out per node (sparsity)
   maxWeight: 6,      // weight at which an edge transmits at full damping
-  halfLifeDays: 60,  // Hebbian weight half-life for decay()
 };
 
 let _db = null;
@@ -62,6 +71,17 @@ function openDb() {
     )`);
     db.exec("CREATE INDEX IF NOT EXISTS edges_src ON edges (src)");
     db.exec("CREATE INDEX IF NOT EXISTS edges_dst ON edges (dst)");
+    // v1 migration: legacy DBs carry weights the old nightly decay() rewrite
+    // had already over-decayed (it reapplied the full age every night). Treat
+    // stored values as current and restart the clock — decay is read-time from
+    // here on, so this is the last time the stamp is touched in bulk.
+    try {
+      const uv = db.prepare("PRAGMA user_version").get() || {};
+      if (Number(uv.user_version || 0) < 1) {
+        db.prepare("UPDATE edges SET last_reinforced=? WHERE last_reinforced IS NOT NULL").run(now());
+        db.exec("PRAGMA user_version = 1");
+      }
+    } catch (e) {}
     _db = db;
     return db;
   } catch (e) {
@@ -76,6 +96,29 @@ function normType(t) {
   return EDGE_TYPES.includes(s) ? s : "related";
 }
 
+// Effective decay half-life: explicit override > dream-tunable knob (env-pinnable).
+function currentHalfLife(opts = {}) {
+  if (Number.isFinite(opts.halfLifeDays)) return Math.max(1, opts.halfLifeDays);
+  let hl;
+  try { hl = require("./tuning").get("decayHalfLifeDays"); } catch (e) {}
+  return Number.isFinite(hl) ? Math.max(1, hl) : 60;
+}
+
+// Read-time weight of an edge row: exponential decay of the stored weight since
+// last_reinforced, clamped at the structural floor. Pure — storage is never
+// touched. An edge that was never reinforced (last_reinforced null) does not
+// decay: it sits at its structural base until first use.
+function effectiveWeight(e, nowMs = Date.now(), halfLifeDays = currentHalfLife()) {
+  if (!e || !Number.isFinite(e.weight)) return 0;
+  if (!e.last_reinforced) return e.weight;
+  const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
+  if (!(ageDays > 0)) return e.weight;
+  const floor = BASE_WEIGHT[e.type] || 0;
+  if (e.weight <= floor) return e.weight;
+  const f = Math.exp(-Math.log(2) * ageDays / Math.max(1, halfLifeDays));
+  return Math.max(floor, e.weight * f);
+}
+
 // Upsert an edge. By default keeps the larger of the existing/new weight so a
 // structural re-derive never stomps reinforcement; pass `{ bump }` to add to
 // the current weight (Hebbian) and stamp last_reinforced.
@@ -86,15 +129,19 @@ function addEdge(src, dst, type, opts = {}) {
   const weight = Number.isFinite(opts.weight) ? opts.weight : (BASE_WEIGHT[t] || 1);
   const bump = Number.isFinite(opts.bump) ? opts.bump : 0;
   try {
-    const existing = db.prepare("SELECT weight FROM edges WHERE src=? AND dst=? AND type=?").get(src, dst, t);
+    const existing = db.prepare("SELECT weight, last_reinforced FROM edges WHERE src=? AND dst=? AND type=?").get(src, dst, t);
     if (existing) {
-      const next = bump ? existing.weight + bump : Math.max(existing.weight, weight);
-      const stamp = bump ? now() : null;
-      if (stamp) {
+      if (bump) {
+        // Settle the decay accrued since last_reinforced, then bump and restamp
+        // — keeps the invariant that the stored weight is valued at its stamp.
+        const settled = effectiveWeight({ ...existing, type: t });
         db.prepare("UPDATE edges SET weight=?, last_reinforced=? WHERE src=? AND dst=? AND type=?")
-          .run(next, stamp, src, dst, t);
+          .run(settled + bump, now(), src, dst, t);
       } else {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, src, dst, t);
+        const next = Math.max(existing.weight, weight);
+        if (next !== existing.weight) {
+          db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, src, dst, t);
+        }
       }
     } else {
       db.prepare("INSERT INTO edges (src, dst, type, weight, last_reinforced, created) VALUES (?,?,?,?,?,?)")
@@ -123,18 +170,21 @@ function allEdges() {
   catch (e) { return []; }
 }
 
-// Undirected neighbours of a node: edges where it is src OR dst.
+// Undirected neighbours of a node: edges where it is src OR dst. Weights are
+// read-time effective values.
 function neighbors(nodeId) {
   const db = openDb();
   if (!db || !nodeId) return [];
   try {
     const rows = db.prepare(
-      "SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?"
+      "SELECT src, dst, type, weight, last_reinforced FROM edges WHERE src=? OR dst=?"
     ).all(nodeId, nodeId);
+    const nowMs = Date.now();
+    const hl = currentHalfLife();
     return rows.map((r) => ({
       node: r.src === nodeId ? r.dst : r.src,
       type: r.type,
-      weight: r.weight,
+      weight: effectiveWeight(r, nowMs, hl),
     }));
   } catch (e) { return []; }
 }
@@ -158,24 +208,30 @@ function reinforceSet(nodeIds, amount = 1) {
 
 // Negative Hebbian: weaken every edge touching a node that keeps surfacing
 // via the graph but never gets kept or used — firing wrongly, so unwire.
-// Same floor contract as decay(); additionally, `related` edges that fall to
-// their structural base are deleted outright: a link-derived edge re-derives
-// at base weight on the next sync (harmless), while a co-use edge that earned
-// its weight from wrong firings is gone for good.
+// Operates on the EFFECTIVE weight (settle accrued decay first, then apply the
+// factor and restamp — same invariant as the reinforce path). Floor contract
+// as everywhere: never below the type's base weight. Additionally, `related`
+// edges that fall to their structural base are deleted outright: a
+// link-derived edge re-derives at base weight on the next sync (harmless),
+// while a co-use edge that earned its weight from wrong firings is gone for
+// good.
 function weakenNode(nodeId, { factor = 0.6, prune = true } = {}) {
   const db = openDb();
   if (!db || !nodeId) return { weakened: 0, pruned: 0 };
   let weakened = 0, pruned = 0;
   try {
-    const rows = db.prepare("SELECT src, dst, type, weight FROM edges WHERE src=? OR dst=?").all(nodeId, nodeId);
+    const rows = db.prepare("SELECT src, dst, type, weight, last_reinforced FROM edges WHERE src=? OR dst=?").all(nodeId, nodeId);
+    const nowMs = Date.now();
+    const hl = currentHalfLife();
+    const stamp = now();
     for (const e of rows) {
       const floor = BASE_WEIGHT[e.type] || 0;
-      const next = Math.max(floor, e.weight * factor);
+      const next = Math.max(floor, effectiveWeight(e, nowMs, hl) * factor);
       if (prune && e.type === "related" && next <= floor + 0.05) {
         db.prepare("DELETE FROM edges WHERE src=? AND dst=? AND type=?").run(e.src, e.dst, e.type);
         pruned++;
       } else if (Math.abs(next - e.weight) > 1e-6) {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?").run(next, e.src, e.dst, e.type);
+        db.prepare("UPDATE edges SET weight=?, last_reinforced=? WHERE src=? AND dst=? AND type=?").run(next, stamp, e.src, e.dst, e.type);
         weakened++;
       }
     }
@@ -183,33 +239,6 @@ function weakenNode(nodeId, { factor = 0.6, prune = true } = {}) {
   return { weakened, pruned };
 }
 
-// Exponential time decay on reinforced weight. Structural floor is preserved:
-// an edge never decays below its type's base weight.
-function decay({ halfLifeDays = DEFAULTS.halfLifeDays } = {}) {
-  const db = openDb();
-  if (!db) return 0;
-  const rows = allEdges();
-  const nowMs = Date.now();
-  const ln2 = Math.log(2);
-  let changed = 0;
-  for (const e of rows) {
-    if (!e.last_reinforced) continue;
-    const ageDays = (nowMs - Date.parse(e.last_reinforced)) / 86400000;
-    if (!(ageDays > 0)) continue;
-    const factor = Math.exp(-ln2 * ageDays / Math.max(1, halfLifeDays));
-    const floor = BASE_WEIGHT[e.type] || 0;
-    const next = Math.max(floor, e.weight * factor);
-    if (Math.abs(next - e.weight) > 1e-6) {
-      try {
-        db.prepare("UPDATE edges SET weight=? WHERE src=? AND dst=? AND type=?")
-          .run(next, e.src, e.dst, e.type);
-        changed++;
-      } catch (e2) {}
-    }
-  }
-  return changed;
-}
-
 // Spreading activation. `seeds` is [{ id, score }] (score = match strength).
 // Returns Map id -> { activation, hop, via } for nodes that fired above the
 // threshold, EXCLUDING the original seeds (those are already in the result set
@@ -220,10 +249,13 @@ function expand(seeds, opts = {}) {
   const seedList = (seeds || []).filter((s) => s && s.id);
   if (!seedList.length || !available()) return out;
 
-  // Build adjacency once, keeping the strongest edge per (node, neighbour).
+  // Build adjacency once over READ-TIME weights, keeping the strongest edge
+  // per (node, neighbour).
   const adj = new Map();
+  const nowMs = Date.now();
+  const hl = currentHalfLife(opts);
   for (const e of allEdges()) {
-    const w = e.weight;
+    const w = effectiveWeight(e, nowMs, hl);
     const push = (from, to) => {
       if (!adj.has(from)) adj.set(from, new Map());
       const m = adj.get(from);
@@ -378,14 +410,14 @@ function pruneOrphans(packsLib, entitiesLib) {
   return removed;
 }
 
-// Nightly maintenance: refresh structural edges, decay reinforced weights,
-// drop orphans. Deterministic + safe — the high-judgment "extract shared
+// Nightly maintenance: refresh structural edges, drop orphans. There is no
+// weight pass — decay is applied on read (effectiveWeight), so nightly has
+// nothing to rewrite. Deterministic + safe — the high-judgment "extract shared
 // concern node" surgery is left to the dream model proper.
-function tend(packsLib, entitiesLib, opts = {}) {
+function tend(packsLib, entitiesLib) {
   const synced = syncFromCorpus(packsLib, entitiesLib);
-  const decayed = decay(opts);
   const pruned = pruneOrphans(packsLib, entitiesLib);
-  return { synced: synced.edges, decayed, pruned, ...stats() };
+  return { synced: synced.edges, pruned, ...stats() };
 }
 
 function stats() {
@@ -404,7 +436,7 @@ module.exports = {
   EDGE_TYPES, DEFAULTS, GRAPH_DB,
   available, openDb,
   addEdge, removeEdge, allEdges, neighbors,
-  reinforce, reinforceSet, decay, weakenNode, expand,
+  reinforce, reinforceSet, effectiveWeight, weakenNode, expand,
   syncFromCorpus, parseLinks, pruneOrphans, tend, stats, isSharedConcern,
   _resetForTest,
 };

package/core/recall/tuning.js

@@ -132,8 +132,7 @@ function history() { return readFile().history || []; }
 
 function write(data) {
   try {
-    fs.mkdirSync(path.dirname(TUNING_FILE), { recursive: true });
-    fs.writeFileSync(TUNING_FILE, JSON.stringify(data, null, 2));
+    require("../fsutil").atomicWriteFileSync(TUNING_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
   } catch (e) {}
   _cache = null; _cacheMtime = -1;
 }

package/core/router.js

@@ -27,6 +27,7 @@ const { MAX_FILE_SIZE, MAX_VOICE_SIZE, FILES_DIR } = require("./config");
 const keyring = require("./keyring");
 const { classifyPastedCredential } = require("./credential-detect");
 const channelWizard = require("./channel-wizard");
+const safeModeLib = require("./safe-mode");
 require("./handlers"); // side-effect: register slash commands
 
 const USER_VISIBLE_PROVIDER_ERRORS = new Set([
@@ -96,6 +97,19 @@ async function onMessage(envelope) {
       // owner's canonical bucket on first contact, before any state is read.
       try { autoLinkOwnerChannel(envelope.adapter?.type, envelope.channelId); } catch (e) {}
 
+      // Safe mode: only the diagnosis/rescue command set runs; everything else
+      // gets a short banner pointing at /safemode. Preempts wizards, media and
+      // agent turns — nothing may write memory or spawn a provider here.
+      if (safeModeLib.isSafeMode()) {
+        const raw = envelope.text || "";
+        const isCommand = envelope.type === "command" || raw.startsWith("/");
+        if (!isCommand || !safeModeLib.commandAllowed(raw)) {
+          if (isDuplicate(envelope)) return;
+          await send(safeModeLib.banner());
+          return;
+        }
+      }
+
       // A channel wizard listening for the owner's message on a freshly-added
       // adapter consumes that inbound message here: it arrives on a different
       // channel than the operator's, so the isAwaiting() gate below (keyed to
@@ -151,6 +165,10 @@ async function onMessage(envelope) {
 async function onAction(envelope) {
   return scope(envelope, async () => {
     try {
+      if (safeModeLib.isSafeMode()) {
+        try { await send(safeModeLib.banner()); } catch (e) {}
+        return;
+      }
       if (await channelWizard.handleAction(envelope)) return;
       await handleAction(envelope);
     }

package/core/runner.js

@@ -1201,6 +1201,7 @@ function deriveCompactionRunContext(base, overrides = {}) {
     resumeSessionId: overrides.resumeSessionId ?? null,
     continueSession: false,
     fresh: !!overrides.fresh,
+    recallQuery: overrides.recallQuery ?? null,
     skipAutoCompact: true,
     requiredDelivery: false,
     readOnly: true,
@@ -1214,6 +1215,25 @@ function deriveCompactionRunContext(base, overrides = {}) {
   });
 }
 
+// The seed turn opens a fresh session, so whatever packs were active before
+// compaction only come back if recall re-attracts them. Match on what the
+// work IS — the condensed brief plus open task titles — rather than the seed
+// prompt's instruction boilerplate.
+function seedRecallQuery(condensedSummary) {
+  const parts = [String(condensedSummary || "").slice(0, 4000)];
+  try {
+    const { currentAdapter, currentChannelId } = require("./context");
+    const adapter = currentAdapter();
+    const channelId = currentChannelId();
+    if (adapter && channelId) {
+      const titles = require("./tasks").pendingSummary(adapter.id, channelId)
+        .map((t) => t.content).filter(Boolean).slice(0, 20);
+      if (titles.length) parts.push(titles.join("\n"));
+    }
+  } catch (_) {}
+  return parts.filter(Boolean).join("\n");
+}
+
 function successfulTerminalCapture(result, { requireSession = false } = {}) {
   return !!result?.ok && result.status === "succeeded" && result.terminalSeen === true
     && (!requireSession || (typeof result.sessionId === "string" && !!result.sessionId));
@@ -1296,6 +1316,7 @@ function createCompactionService(dependencies = {}) {
         previousSessionId: oldSessionId,
         fresh: true,
         outputSchemaPath,
+        recallQuery: seedRecallQuery(condensed || fullBrief),
       });
       const seedRun = await runCapture(seedPrompt, seedContext.cwd || cwd, {
         runContext: seedContext,

package/core/safe-mode.js

@@ -0,0 +1,227 @@
+// Safe-mode boot gate. Two failure classes land here instead of running (or
+// dying) blind:
+//   1) REQUIRED substrate missing — no node:sqlite means no pack FTS, no
+//      recall graph, no episodes. A pod once ran 16 days like that, silently.
+//      Running degraded is now an explicit operator choice, never a default.
+//   2) Boot crash loop — N consecutive boots died before reaching stable
+//      uptime. A hard exit here would strand the operator with a dead chat;
+//      safe mode keeps the channel alive so /doctor, /upgrade, /downgrade and
+//      /safemode continue can rescue it FROM CHAT.
+// Safe mode boots adapters + slash commands only: no scheduler, no crons, no
+// agent turns, no reviewer. bot.js consults beginBoot() once at startup;
+// router.js gates every message through isSafeMode()/commandAllowed().
+
+const fs = require("fs");
+const path = require("path");
+const CONFIG_DIR = require("../config-dir");
+const { sqliteAvailable } = require("./doctor-memory");
+
+const MARKER_FILE = path.join(CONFIG_DIR, "boot-marker.json");
+const CONTINUE_FILE = path.join(CONFIG_DIR, "safemode-continue.json");
+const VERSION_HISTORY_FILE = path.join(CONFIG_DIR, "version-history.json");
+
+const CRASH_LOOP_THRESHOLD = 3;
+const STABLE_UPTIME_MS = 5 * 60 * 1000;
+const CONTINUE_FRESH_MS = 15 * 60 * 1000;
+const VERSION_HISTORY_CAP = 20;
+
+// Commands that still work in safe mode: diagnosis + the ways out. Everything
+// else (agent turns, memory, schedulers, wizards) is paused.
+const SAFE_COMMANDS = new Set([
+  "help", "start", "version", "status", "doctor", "requirements",
+  "restart", "upgrade", "downgrade", "safemode", "whoami", "cluster",
+]);
+
+let _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: null };
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf-8")); } catch (_) { return null; }
+}
+
+function writeJson(file, value) {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, JSON.stringify(value), { mode: 0o600 });
+    return true;
+  } catch (_) { return false; }
+}
+
+// Pure decision, unit-testable. degradedAllowed = explicit env override;
+// continueRequested = one-shot /safemode continue flag (also resets the loop).
+function decideBootMode({ sqliteOk, crashCount, degradedAllowed, continueRequested }) {
+  const reasons = [];
+  const effectiveCrashes = continueRequested ? 0 : crashCount;
+  if (!sqliteOk && !degradedAllowed && !continueRequested) reasons.push("substrate");
+  if (effectiveCrashes >= CRASH_LOOP_THRESHOLD) reasons.push("crash-loop");
+  if (reasons.length) return { mode: "safe", reasons };
+  return { mode: sqliteOk ? "full" : "degraded", reasons: [] };
+}
+
+function recordVersionSeen(version, now = Date.now()) {
+  if (!version) return;
+  const history = Array.isArray(readJson(VERSION_HISTORY_FILE)) ? readJson(VERSION_HISTORY_FILE) : [];
+  const last = history[history.length - 1];
+  if (last && last.version === version) return;
+  history.push({ version, at: new Date(now).toISOString() });
+  writeJson(VERSION_HISTORY_FILE, history.slice(-VERSION_HISTORY_CAP));
+}
+
+// Most recent version in boot history that differs from the current one — the
+// default /downgrade target ("what ran before this").
+function previousVersion(current) {
+  const history = readJson(VERSION_HISTORY_FILE);
+  if (!Array.isArray(history)) return null;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const v = history[i] && history[i].version;
+    if (v && v !== current) return v;
+  }
+  return null;
+}
+
+function consumeContinueFlag(now = Date.now()) {
+  const flag = readJson(CONTINUE_FILE);
+  try { fs.rmSync(CONTINUE_FILE, { force: true }); } catch (_) {}
+  if (!flag || !flag.at) return false;
+  return now - Date.parse(flag.at) < CONTINUE_FRESH_MS;
+}
+
+function requestContinue() {
+  return writeJson(CONTINUE_FILE, { at: new Date().toISOString() });
+}
+
+// Called once per process at the very top of bot.js. Counts crash-loop state
+// from the previous boot marker + exit record, decides the boot mode, writes
+// this boot's marker. Crash rule: the previous incarnation counts as a crash
+// iff it never reached stable uptime AND did not record a clean (code 0)
+// deliberate exit. A safe-mode incarnation preserves the count (safe mode
+// being stable must not launder the loop away) — only markBootStable(),
+// /safemode continue, or a deliberate version change resets it.
+function beginBoot({ exitInfo = null, currentVersion = "", env = process.env, now = Date.now() } = {}) {
+  try {
+    // Test runs boot bot.js repeatedly and kill it hard; marker counting would
+    // sabotage the suite. The feature's own tests opt back in explicitly.
+    if (env.OPEN_CLAUDIA_TEST === "1" && env.OPEN_CLAUDIA_SAFEMODE_TEST !== "1") {
+      _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: exitInfo };
+      return { ..._state };
+    }
+    recordVersionSeen(currentVersion, now);
+    const prev = readJson(MARKER_FILE);
+    const cleanExit = !!(exitInfo && Number(exitInfo.code) === 0);
+    const crashed = !!(prev && !prev.stable && !cleanExit);
+    const baseCount = prev ? Number(prev.consecutiveCrashes) || 0 : 0;
+    const crashCount = crashed ? baseCount + 1 : (prev && prev.mode === "safe" ? baseCount : 0);
+    const continueRequested = consumeContinueFlag(now);
+    const decision = decideBootMode({
+      sqliteOk: sqliteAvailable(),
+      crashCount,
+      degradedAllowed: env.MEMORY_ALLOW_DEGRADED === "1",
+      continueRequested,
+    });
+    const effectiveCount = continueRequested ? 0 : crashCount;
+    writeJson(MARKER_FILE, {
+      bootedAt: new Date(now).toISOString(),
+      pid: process.pid,
+      mode: decision.mode,
+      // The safe-mode process itself is stable; its marker must still carry
+      // the count so a plain /restart re-enters safe mode instead of retrying
+      // the crashing full boot.
+      stable: decision.mode === "safe",
+      consecutiveCrashes: effectiveCount,
+      version: currentVersion,
+    });
+    _state = {
+      mode: decision.mode,
+      reasons: decision.reasons,
+      consecutiveCrashes: effectiveCount,
+      prevExit: exitInfo,
+    };
+    return { ..._state };
+  } catch (e) {
+    // The gate must never itself brick a boot.
+    try { console.error("safe-mode beginBoot failed:", e.message); } catch (_) {}
+    _state = { mode: "full", reasons: [], consecutiveCrashes: 0, prevExit: exitInfo };
+    return { ..._state };
+  }
+}
+
+// Full/degraded boots call this after STABLE_UPTIME_MS: the incarnation
+// proved itself, so the crash streak resets.
+function markBootStable() {
+  const marker = readJson(MARKER_FILE);
+  if (!marker) return;
+  marker.stable = true;
+  marker.consecutiveCrashes = 0;
+  writeJson(MARKER_FILE, marker);
+}
+
+// A deliberate version change (/upgrade, /downgrade) is an operator fix
+// attempt: give the next boot a clean slate.
+function clearCrashLoop() {
+  const marker = readJson(MARKER_FILE);
+  if (!marker) return;
+  marker.consecutiveCrashes = 0;
+  if (marker.mode === "safe") marker.mode = "full";
+  writeJson(MARKER_FILE, marker);
+}
+
+function isSafeMode() {
+  return _state.mode === "safe";
+}
+
+function bootInfo() {
+  return { ..._state };
+}
+
+function commandAllowed(text) {
+  const t = String(text || "").trim();
+  if (!t.startsWith("/")) return false;
+  const word = t.slice(1).split(/\s+/)[0].split("@")[0].toLowerCase();
+  return SAFE_COMMANDS.has(word);
+}
+
+function reasonLines() {
+  const lines = [];
+  for (const r of _state.reasons) {
+    if (r === "substrate") {
+      lines.push(`• Memory substrate missing: Node ${process.version} has no node:sqlite (Open Claudia requires Node ≥24).`);
+    } else if (r === "crash-loop") {
+      lines.push(`• Boot crash loop: ${_state.consecutiveCrashes} consecutive boots died before reaching stable uptime.`);
+    }
+  }
+  return lines;
+}
+
+function lastExitLine() {
+  if (_state.prevExit && _state.prevExit.reason) return `Last exit: ${_state.prevExit.reason}`;
+  return "Last exit: hard kill — no exit record (OOM, SIGKILL, or a crash before any handler ran).";
+}
+
+function banner() {
+  const why = _state.reasons.includes("substrate") ? "memory substrate missing" : "boot crash loop";
+  return `⛔ Safe mode (${why}) — normal turns are paused. /safemode shows details and ways out; /doctor /status /upgrade /downgrade /restart still work.`;
+}
+
+function formatSafeModeAlert({ version = "" } = {}) {
+  return [
+    `⛔ SAFE MODE — Open Claudia v${version} booted with normal operation suspended.`,
+    ...reasonLines(),
+    lastExitLine(),
+    "",
+    "No agent turns, crons, watches or memory writes will run in this state.",
+    "Working commands: /doctor /status /version /cluster /upgrade /downgrade [version] /restart /safemode continue /help",
+    "",
+    "Ways out:",
+    "• /upgrade — install the latest release",
+    "• /downgrade — roll back to the previously-running version",
+    "• /safemode continue — boot normally anyway (keyword-only memory if the substrate is missing)",
+    "• Fix the runtime (pods: roll to the node:24 image), then /restart",
+  ].join("\n");
+}
+
+module.exports = {
+  MARKER_FILE, CONTINUE_FILE, VERSION_HISTORY_FILE,
+  CRASH_LOOP_THRESHOLD, STABLE_UPTIME_MS, SAFE_COMMANDS,
+  decideBootMode, beginBoot, markBootStable, clearCrashLoop,
+  recordVersionSeen, previousVersion, requestContinue,
+  isSafeMode, bootInfo, commandAllowed, banner, formatSafeModeAlert,
+};

package/core/state.js

@@ -629,10 +629,10 @@ function seedConversationContinuity(state) {
   if (!isRecord(legacy) || isRecord(state.activeSessions[convo])) return;
   state.activeSessions[convo] = { ...legacy };
   if (isRecord(state.usageBySession)) {
-    const prefix = "Workspace";
+    const prefix = "Workspace\u0000";
     for (const [key, usage] of Object.entries(state.usageBySession)) {
       if (key.startsWith(prefix) && isRecord(usage)) {
-        const moved = `${convo}${key.slice(prefix.length)}`;
+        const moved = `${convo}\u0000${key.slice(prefix.length)}`;
         if (!state.usageBySession[moved]) state.usageBySession[moved] = { ...usage };
       }
     }

package/core/system-prompt.js

@@ -539,6 +539,23 @@ function consumeLastInjected() {
   return out;
 }
 
+// A Stance line carrying the word LOCKED (uppercase — prose "locked" stays
+// put) is a constraint the user explicitly froze. The branding-font incident
+// showed such a line sitting mid-Stance reads as background prose and gets
+// violated; hoist LOCKED lines under a must-follow header so they carry rule
+// authority in every injection mode.
+function formatStanceSection(stance) {
+  const lines = stance.split("\n");
+  const locked = lines.map((l) => l.trim()).filter((l) => l && /\bLOCKED\b/.test(l));
+  if (!locked.length) return stance;
+  const rest = lines.filter((l) => !/\bLOCKED\b/.test(l)).join("\n").trim();
+  const block = [
+    "BINDING CONSTRAINTS (LOCKED — follow exactly; do not deviate or reinterpret unless the user explicitly unlocks them this turn):",
+    ...locked.map((l) => (/^[-*]/.test(l) ? l : `- ${l}`)),
+  ].join("\n");
+  return rest ? `${block}\n\n${rest}` : block;
+}
+
 function formatPackForContext(pack, packsLib, opts = {}) {
   const extractive = !!opts.extractive;
   const headline = !!opts.headline;
@@ -564,7 +581,7 @@ function formatPackForContext(pack, packsLib, opts = {}) {
   // still used by the classic engine and as the fallback when no lines matched.
   if (extractive) {
     const stance = (pack.sections.Stance || "").trim();
-    if (stance) parts.push(`#### Stance\n${stance}`);
+    if (stance) parts.push(`#### Stance\n${formatStanceSection(stance)}`);
     const stanceLow = stance.toLowerCase();
     const bySection = new Map();
     for (const h of (Array.isArray(opts.matchedLines) ? opts.matchedLines : [])) {
@@ -598,7 +615,7 @@ function formatPackForContext(pack, packsLib, opts = {}) {
       : ["Stance", "Procedure", "State"];
     for (const section of sections) {
       const body = (pack.sections[section] || "").trim();
-      if (body) parts.push(`#### ${section}\n${body}`);
+      if (body) parts.push(`#### ${section}\n${section === "Stance" ? formatStanceSection(body) : body}`);
     }
     if (headline) {
       const hidden = ["State", "Procedure", "Journal"].filter((s) => (pack.sections[s] || "").trim());
@@ -984,7 +1001,25 @@ function voiceReplyGuidance(opts = {}) {
 
 async function buildOptionalRecallContext(prompt, opts = {}) {
   const collector = { packs: [], packDirs: [], entities: [], recall: null };
-  const { userText, contextText } = recallMatchParts(prompt);
+  // Compaction meta-turns: the summarizer's prompt is instructions about
+  // summarizing, so matching packs against it is pure noise — skip recall.
+  // The seed turn is the opposite: it opens a FRESH session, so recall is the
+  // only way the packs active before compaction come back — match on the
+  // runner-supplied recallQuery (condensed brief + open task titles), not the
+  // seed prompt's boilerplate.
+  if (opts.runContext?.purpose === "compact-summary") {
+    return {
+      dynamicContext: "",
+      metadata: { status: "omitted", omitted: true, reason: "compaction_meta_turn" },
+      legacy: collector,
+    };
+  }
+  const queryOverride = typeof opts.runContext?.recallQuery === "string" && opts.runContext.recallQuery.trim()
+    ? opts.runContext.recallQuery
+    : null;
+  const { userText, contextText } = queryOverride
+    ? { userText: stripRecallAnnouncements(queryOverride), contextText: "" }
+    : recallMatchParts(prompt);
   let historyText = "";
   try {
     historyText = stripRecallAnnouncements(require("./transcripts").recentTranscriptText({ limit: 6 }, promptState(opts)));
@@ -1085,12 +1120,17 @@ function createPromptBuilder(dependencies = {}) {
           throw new TypeError("recall builder returned an invalid result");
         }
       } catch (error) {
+        // Fail-open by design (a broken recall must not block the turn), but
+        // never silently: the error goes to the bot log here, and the turn
+        // observer counts consecutive failures and alerts the owner (B5).
+        try { console.error("[recall] builder failed:", error?.message || error); } catch (_) {}
         recallResult = {
           dynamicContext: "",
           metadata: {
             status: "omitted",
             omitted: true,
             reason: "optional_recall_unavailable",
+            detail: String(error?.message || error).slice(0, 200),
           },
           legacy: { packs: [], packDirs: [], entities: [], recall: null },
         };