@inetafrica/open-claudia 3.0.44 → 3.1.1

package/core/memory-mutation-queue.js

@@ -8,8 +8,17 @@ const CONFIG_DIR = require("../config-dir");
 const DEFAULT_MAX_PENDING = 50;
 const DEFAULT_LOCK_TIMEOUT_MS = 30 * 1000;
 const DEFAULT_LOCK_POLL_MS = 25;
-const DEFAULT_STALE_LOCK_MS = 30 * 60 * 1000;
 const DEFAULT_DRAIN_TIMEOUT_MS = 5000;
+// A lock dir whose owner.json never landed (crash inside the mkdir→write
+// window) is an orphan once it outlives this grace.
+const ORPHAN_LOCK_GRACE_MS = 5000;
+
+// Distinguishes process INCARNATIONS sharing a pid. In a container the bot is
+// pid 1 and a restarted bot is ALSO pid 1, so pid-liveness alone made a lock
+// left by a crashed incarnation look held forever — every writer then timed
+// out (measured on a pod with 43 restarts: 87% of reviewer runs failed with
+// MEMORY_MUTATION_LOCK_TIMEOUT and pack capture starved for 16 days).
+const BOOT_ID = crypto.randomBytes(8).toString("hex");
 
 class MutationQueueError extends Error {
   constructor(code, message, details = {}) {
@@ -44,20 +53,33 @@ function safeMetadata(metadata) {
   return result;
 }
 
-function ownerIsAlive(lockDir) {
-  let owner;
-  try { owner = JSON.parse(fs.readFileSync(path.join(lockDir, "owner.json"), "utf8")); }
-  catch (_) { return false; }
-  const pid = Number(owner?.pid);
-  if (!Number.isSafeInteger(pid) || pid < 1) return false;
+function readOwner(lockDir) {
+  try { return JSON.parse(fs.readFileSync(path.join(lockDir, "owner.json"), "utf8")); }
+  catch (_) { return null; }
+}
+
+function pidLooksAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isSafeInteger(n) || n < 1) return false;
   try {
-    process.kill(pid, 0);
+    process.kill(n, 0);
     return true;
   } catch (error) {
     return error.code === "EPERM";
   }
 }
 
+// Is a held lock safe to break? Never for a live holder; immediately for a
+// dead one. owner.pid === our pid means either ourselves (same bootId — never
+// break) or a previous incarnation that reused our pid (container pid-1 case —
+// definitionally dead, break at once).
+function lockIsStale(lockDir, ageMs) {
+  const owner = readOwner(lockDir);
+  if (!owner) return ageMs > ORPHAN_LOCK_GRACE_MS;
+  if (Number(owner.pid) === process.pid) return owner.bootId !== BOOT_ID;
+  return !pidLooksAlive(owner.pid);
+}
+
 class MemoryMutationQueue {
   constructor(options = {}) {
     this.lockDir = options.lockDir || path.join(CONFIG_DIR, "memory-mutation.lock");
@@ -65,7 +87,6 @@ class MemoryMutationQueue {
     this.maxPending = positiveInteger(options.maxPending, DEFAULT_MAX_PENDING, "maxPending");
     this.lockTimeoutMs = positiveInteger(options.lockTimeoutMs, DEFAULT_LOCK_TIMEOUT_MS, "lockTimeoutMs");
     this.lockPollMs = positiveInteger(options.lockPollMs, DEFAULT_LOCK_POLL_MS, "lockPollMs");
-    this.staleLockMs = positiveInteger(options.staleLockMs, DEFAULT_STALE_LOCK_MS, "staleLockMs");
     this.accepting = true;
     this.stopReason = null;
     this.pending = new Map();
@@ -93,7 +114,7 @@ class MemoryMutationQueue {
       try {
         fs.mkdirSync(this.lockDir, { recursive: false, mode: 0o700 });
         try {
-          fs.writeFileSync(path.join(this.lockDir, "owner.json"), `${JSON.stringify({ token, pid: process.pid, id: entry.id, at: new Date().toISOString() })}\n`, { mode: 0o600 });
+          fs.writeFileSync(path.join(this.lockDir, "owner.json"), `${JSON.stringify({ token, pid: process.pid, bootId: BOOT_ID, id: entry.id, at: new Date().toISOString() })}\n`, { mode: 0o600 });
         } catch (error) {
           try { fs.rmSync(this.lockDir, { recursive: true, force: true }); } catch (_) {}
           throw error;
@@ -107,7 +128,7 @@ class MemoryMutationQueue {
 
       try {
         const age = Date.now() - fs.statSync(this.lockDir).mtimeMs;
-        if (age > this.staleLockMs && !ownerIsAlive(this.lockDir)) {
+        if (lockIsStale(this.lockDir, age)) {
           fs.rmSync(this.lockDir, { recursive: true, force: true });
         }
       } catch (_) { /* another process may have released it */ }
@@ -230,6 +251,15 @@ class MemoryMutationQueue {
   }
 }
 
+// Read-only view of the shared lock for health surfaces (/doctor).
+function inspectLock(lockDir) {
+  const dir = lockDir || path.join(CONFIG_DIR, "memory-mutation.lock");
+  let stat;
+  try { stat = fs.statSync(dir); } catch (_) { return { held: false }; }
+  const ageMs = Date.now() - stat.mtimeMs;
+  return { held: true, ageMs, owner: readOwner(dir), stale: lockIsStale(dir, ageMs) };
+}
+
 const memoryMutationQueue = new MemoryMutationQueue();
 
 module.exports = {
@@ -238,4 +268,5 @@ module.exports = {
   MemoryMutationQueue,
   MutationQueueError,
   memoryMutationQueue,
+  inspectLock,
 };

package/core/pack-review.js

@@ -7,8 +7,12 @@
 // rule.
 
 const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
 const { spawnUtilityAgent, cancelUtilityAgents } = require("./utility-agent");
 const { memoryMutationQueue } = require("./memory-mutation-queue");
+const { atomicWriteFileSync } = require("./fsutil");
+const CONFIG_DIR = require("../config-dir");
 const packs = require("./packs");
 const entities = require("./entities");
 const lessons = require("./lessons");
@@ -160,6 +164,7 @@ Decide. Rules:
 - Bias toward action: if the turn did real work on an identifiable topic (a named system, project, server, app, person, or domain), record it — at minimum a journal line. Most working turns deserve one. Reserve empty actions for small talk, pure status checks, and turns that contain nothing new.
 - ATTRIBUTION: prefer updating one of the ACTIVE packs above. The turn text often does not name its project (pronouns, follow-ups, pasted URLs) — never attribute the work to a different pack from the index on thematic similarity alone when an active pack fits the work.
 - State/Stance/Procedure rewrites are MERGES, never regenerations: start from the pack's CURRENT content shown in the ACTIVE block above, carry forward every fact that is still true, drop only what this turn contradicted or completed, then fold in what changed. Never drop a durable fact merely because this turn did not mention it. If a pack's current content is NOT shown above, do not rewrite its sections — record a journal line only (section rewrites there are discarded).
+- LOCKED lines: a Stance line containing the word LOCKED is a constraint the user explicitly froze. NEVER weaken, reword, or drop a LOCKED line in a stance rewrite — carry it forward verbatim — unless THIS turn shows the user explicitly unlocking or changing it. COMPLIANCE CHECK: compare the assistant's reply against every LOCKED line in the ACTIVE packs above; if the reply violated one (did what the line forbids, or contradicted the locked choice), append a journal line on that pack recording it, e.g. "VIOLATION: reply used <X> where Stance locks <Y>." — violations must become visible, never silently absorbed.
 - UPDATE an existing pack when the turn touched that topic: append a journal line, and rewrite State if where-things-stand changed. Update Stance when the user expressed a lasting preference or rule; Procedure when a verified working method emerged.
 - PROMOTE durable conclusions out of the Journal. A confirmed root-cause diagnosis, an established fact, or a settled design decision must go into Stance/Procedure/State (the parts always injected in full), NOT only a Journal line — Journal is truncated to the last few lines on injection, so a conclusion left only there will silently fall out of recall over time.
 - CREATE a pack ONLY when the turn worked on a durable topic that NO existing pack covers. Before creating, scan the existing packs above for one already about this project/system/domain — if one exists, UPDATE it instead. A new pack must be a genuinely DISTINCT topic, never a narrower facet, version, release, sub-feature, phase, or component of a topic an existing pack already owns. In particular: a release or version of a project (e.g. a pack named after "<project> v2.6.39") is a Journal line + State update on that project's EXISTING pack — NEVER its own pack. Likewise sub-features of one system belong in that system's pack, not in siblings. When unsure whether something is a new topic or a facet of an existing one, treat it as a facet and UPDATE. Do not create packs for one-off trivia.
@@ -533,10 +538,38 @@ function reviewerMetric(entry) {
   try { require("./recall/metrics").logReviewerRun(entry); } catch (_) {}
 }
 
+// Lock-timeout seatbelt. A decision that cannot get the mutation lock even
+// after one retry used to be dropped on the floor — on one pod 87% of
+// reviewer runs lost their computed mutations this way and nobody could see
+// what was lost. Persist it instead (capped, no auto-replay: pack state may
+// have moved on, so /doctor surfaces the backlog and a human decides).
+const DEFERRED_FILE = path.join(CONFIG_DIR, "pending-review-mutations.jsonl");
+const MAX_DEFERRED = 20;
+const LOCK_RETRY_DELAY_MS = 60 * 1000;
+
+function persistDeferredDecision(entry) {
+  try {
+    let lines = [];
+    try { lines = fs.readFileSync(DEFERRED_FILE, "utf-8").trim().split("\n").filter(Boolean); } catch (_) {}
+    lines.push(JSON.stringify(entry));
+    atomicWriteFileSync(DEFERRED_FILE, lines.slice(-MAX_DEFERRED).join("\n") + "\n", { mode: 0o600 });
+    return true;
+  } catch (_) { return false; }
+}
+
+function listDeferredDecisions() {
+  try {
+    return fs.readFileSync(DEFERRED_FILE, "utf-8").trim().split("\n").filter(Boolean)
+      .map((l) => { try { return JSON.parse(l); } catch (_) { return null; } })
+      .filter(Boolean);
+  } catch (_) { return []; }
+}
+
 function createPackReviewer(dependencies = {}) {
   const runUtility = dependencies.spawnUtilityAgent || spawnUtilityAgent;
   const queue = dependencies.mutationQueue || memoryMutationQueue;
   const cancelUtilities = dependencies.cancelUtilityAgents || cancelUtilityAgents;
+  const lockRetryDelayMs = dependencies.lockRetryDelayMs ?? LOCK_RETRY_DELAY_MS;
   const handles = new Map();
   let accepting = true;
 
@@ -586,7 +619,7 @@ function createPackReviewer(dependencies = {}) {
           reviewerMetric({ provider: utilityResult.provider, model: utilityResult.model, status: "no_change", fallbackUsed: utilityResult.fallbackUsed });
           return { status: "no_change", provider: utilityResult.provider, model: utilityResult.model, fallbackUsed: !!utilityResult.fallbackUsed };
         }
-        const applied = await queue.enqueue("review", () => applyDecisionBatch({
+        const enqueueApply = () => queue.enqueue("review", () => applyDecisionBatch({
           decision,
           activePacks,
           versions,
@@ -597,6 +630,27 @@ function createPackReviewer(dependencies = {}) {
           purpose: "review",
           runId,
         });
+        let applied;
+        try {
+          applied = await enqueueApply();
+        } catch (error) {
+          if (error.code !== "MEMORY_MUTATION_LOCK_TIMEOUT") throw error;
+          await new Promise((resolve) => setTimeout(resolve, lockRetryDelayMs));
+          try {
+            applied = await enqueueApply();
+          } catch (retryError) {
+            if (retryError.code === "MEMORY_MUTATION_LOCK_TIMEOUT") {
+              retryError.deferred = persistDeferredDecision({
+                at: new Date().toISOString(),
+                source: source || "",
+                provider: utilityResult.provider || "",
+                model: utilityResult.model || "",
+                decision,
+              });
+            }
+            throw retryError;
+          }
+        }
         let announcementFailed = false;
         if (applied.lines.length && typeof announce === "function") {
           try { await announce(formatAnnouncement(applied.lines)); }
@@ -619,10 +673,11 @@ function createPackReviewer(dependencies = {}) {
           try { await announce(formatAnnouncement(partialLines)); }
           catch (_) { announcementFailed = true; }
         }
-        reviewerMetric({ provider: resolvedProvider, model: utilityResult?.model || "", status: "failed", code: error.code || "REVIEW_FAILED" });
-        console.warn(`[pack-review] reviewer failed: ${error.message}`);
+        const status = error.deferred ? "deferred" : "failed";
+        reviewerMetric({ provider: resolvedProvider, model: utilityResult?.model || "", status, code: error.code || "REVIEW_FAILED" });
+        console.warn(`[pack-review] reviewer ${status}: ${error.message}`);
         return {
-          status: "failed",
+          status,
           provider: resolvedProvider || null,
           model: utilityResult?.model || null,
           lines: partialLines,
@@ -690,6 +745,7 @@ module.exports = {
   contentVersion,
   createPackReviewer,
   drainReviews: defaultReviewer.drainReviews,
+  listDeferredDecisions,
   parseDecision,
   provenanceTag,
   reviewTurn: defaultReviewer.reviewTurn,

package/core/packs.js

@@ -528,7 +528,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;
@@ -609,6 +609,50 @@ function queryTerms(text) {
   return terms;
 }
 
+// Pure-JS floor under matchPacks for substrates without node:sqlite (a
+// node-20 pod once ran 16 days with zero recall because the matcher bailed
+// silently). Same shape and scoring as the FTS path; porter stemming is
+// approximated by substring hits on the term plus a suffix-stripped variant.
+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 = listPacks().map((p) => ({
+    dir: p.dir,
+    name: p.name,
+    strong: [p.name, p.description, p.tags.join(" ")].join("\n").toLowerCase(),
+    body: [p.sections.Stance, p.sections.Procedure, p.sections.State, p.sections.Journal].join("\n").toLowerCase(),
+  }));
+  _lexicalDocsAt = mtime;
+  return _lexicalDocs;
+}
+
+function matchPacksLexical(text, { limit = 3, threshold = null } = {}) {
+  const terms = queryTerms(text);
+  if (terms.length === 0) return [];
+  const minScore = threshold ?? Number(process.env.PACK_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({ dir: doc.dir, name: doc.name, score });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, Math.max(1, Math.min(10, limit)));
+}
+
 // Match a free-text message against packs. BM25 is unusable here — with
 // a small corpus its IDF term collapses to ~0 — so score per term
 // instead: a hit in name/description/tags counts 2 (porter-stemmed via
@@ -616,14 +660,14 @@ function queryTerms(text) {
 // single incidental body word (score 1) never drags a pack in.
 function matchPacks(text, { limit = 3, threshold = null } = {}) {
   const db = openDb();
-  if (!db) return [];
+  if (!db) return matchPacksLexical(text, { limit, threshold });
   ensureIndex();
   const terms = queryTerms(text);
   if (terms.length === 0) return [];
   const minScore = threshold ?? Number(process.env.PACK_MATCH_THRESHOLD || 2);
   const scores = new Map();
   let stmt;
-  try { stmt = db.prepare("SELECT dir FROM packs WHERE packs MATCH ?"); } catch (e) { return []; }
+  try { stmt = db.prepare("SELECT dir FROM packs WHERE packs MATCH ?"); } catch (e) { return matchPacksLexical(text, { limit, threshold }); }
   for (const t of terms) {
     const quoted = `"${t.replace(/"/g, '""')}"`;
     let strong = [];

package/core/recall/discoverer.js

@@ -150,18 +150,34 @@ function maybeSync(packsLib, entitiesLib) {
 // seed — with a 147-pack corpus that is virtually every turn (measured: gated
 // 0.4% of 500 turns), so "thanks!" still paid a full 13s walk. Three tiers:
 //   skip  — pure pleasantry/ack/emoji: no recall at all, regardless of seeds.
-//   seeds — short command-like turns (≤4 words): keyword seeds are precise
-//           enough; inject user-origin seeds directly and skip graph + walker
-//           (the classic baseline, ~ms instead of ~13s).
+//   seeds — short command-like turns (≤4 words after any pleasantry prefix):
+//           keyword seeds are precise enough; inject user-origin seeds directly
+//           and skip graph + walker (the classic baseline, ~ms instead of ~13s).
 //   full  — substantive turns: graph expansion + walker judgement.
 const PLEASANTRY_RE = /^(ok(ay)?|k|kk|thanks?|thank you|thx|ty|yes|yep|yeah|no|nope|nah|cool|nice|great|perfect|awesome|lovely|done|sure|got it|sounds good|will do|lol|haha|hi|hey|hello|yo|morning|evening|night|good (morning|afternoon|evening|night)|bye|goodnight|cheers|please do|go ahead)\b/;
 
+// B2: a pleasantry PREFIX must not hide a real request from the gate — "ok
+// deploy kazee now" is a deploy command wearing an ack, yet the old ≤4-word
+// rule skipped recall for it entirely. Strip leading pleasantry tokens
+// (stacked ones too) plus separators and tier what remains; a pure pleasantry
+// chain strips to "" and skips regardless of its length.
+function stripPleasantryPrefix(t) {
+  let s = t;
+  for (;;) {
+    const m = PLEASANTRY_RE.exec(s);
+    if (!m) return s;
+    s = s.slice(m[0].length).replace(/^[\s,.!?;:—–-]+/, "");
+    if (!s) return "";
+  }
+}
+
 function recallTier(userText, seedCount) {
   const t = String(userText || "").trim().toLowerCase();
   if (!t) return "skip";
-  const words = t.split(/\s+/).filter(Boolean);
   if (!/[a-z0-9]/.test(t)) return "skip"; // emoji/punctuation only
-  if (words.length <= 4 && PLEASANTRY_RE.test(t)) return "skip";
+  const core = stripPleasantryPrefix(t);
+  if (!core) return "skip"; // pure pleasantry/ack chain
+  const words = core.split(/\s+/).filter(Boolean);
   if (words.length <= 2 && seedCount === 0) return "skip";
   if (words.length <= tuning.get("seedsTierMaxWords")) return "seeds";
   return "full";
@@ -325,7 +341,7 @@ function cokeptPairs(keptIds, scoreById, groundedIds, { minScore = 60, maxPairs
       pairs.push({ a, b, strength: scoreById.get(a) + scoreById.get(b) });
     }
   }
-  pairs.sort((x, y) => y.strength - x.strength || (x.a + "" + x.b).localeCompare(y.a + "" + y.b));
+  pairs.sort((x, y) => y.strength - x.strength || (x.a + "\u0000" + x.b).localeCompare(y.a + "\u0000" + y.b));
   return pairs.slice(0, Math.max(0, maxPairs)).map((p) => [p.a, p.b]);
 }
 

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);
     }