@inetafrica/open-claudia 3.0.43 → 3.1.0

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

@@ -375,7 +375,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 +693,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 +764,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 +814,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 +826,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,
@@ -1488,7 +1603,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"}`,

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.

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 = [];