claude-mem-lite 6.23.3 → 6.24.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.23.3",
+      "version": "6.24.0",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.23.3",
+  "version": "6.24.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/README.md

@@ -237,6 +237,27 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
     repos/               # Shallow-cloned source repos
 ```
 
+## Upgrading to 6.24.0
+
+**If you set `CLAUDE_CONFIG_DIR`, the installer, updates and hooks now use that directory, as
+Claude Code does.** No schema-version change: 6.23.3 still opens the database after this
+release has. Without `CLAUDE_CONFIG_DIR` nothing in this item changes.
+
+- **Who is affected.** Claude Code keeps `settings.json`, `plugins/` and `.claude.json` in
+  `CLAUDE_CONFIG_DIR` when it is set. The plugin kept using `~/.claude` and `~/.claude.json`:
+  `install` wrote its hooks where Claude Code never reads them, and with two profiles the
+  session-start setup and `self-update` pruned the other profile's plugin cache and edited its
+  `.claude.json`.
+- **What to do.** Installed with npm or npx: run `claude-mem-lite install` once more with the
+  variable set, so the hooks land in your config directory. Plugin installs need nothing. Hook
+  entries an older version wrote into `~/.claude/settings.json` stay there; if no other profile
+  uses `~/.claude`, `env -u CLAUDE_CONFIG_DIR claude-mem-lite cleanup-hooks` removes them.
+- **Also in this release:** `npm install -g claude-mem-lite` and `npx` no longer install the
+  development toolchain (96 packages / 57 MB instead of 298 / 541 MB). A confirmed
+  `maintain execute --ops purge_stale` now deletes every row its preview counted in one run,
+  behind one snapshot. `doctor` warns about a failing update check and about an
+  `ANTHROPIC_BASE_URL` that ends in `/v1`. Details in CHANGELOG.md.
+
 ## Upgrading to 6.23.1
 
 **If you set `ANTHROPIC_BASE_URL` and `ANTHROPIC_API_KEY`, background LLM calls now go to that
@@ -568,9 +589,13 @@ depends on the Claude Code version. Allow the server once in the `settings.json`
 { "permissions": { "allow": ["mcp__plugin_claude-mem-lite_mem-lite"] } }
 ```
 
-That is the server's name under a plugin install. An npx or git-clone install registers it as
+For a single run, `claude -p … --allowedTools "mcp__plugin_claude-mem-lite_mem-lite"` does the
+same (both forms checked on 2.1.292, 2026-10-07: no refusal, and `mem_search` answered). That is
+the server's name under a plugin install. An npx or git-clone install registers it as
 `mem-lite`, so the rule there is `mcp__mem-lite`. An interactive session asks instead; answering
-"always allow" there records a rule of its own.
+"always allow" there records a rule of its own. The plugin does not tell the model to fall back
+to the CLI when a call is refused: the refusal is Claude Code's permission check for a tool you
+have not allowed, and routing the same action through Bash would sidestep it.
 
 ### Skill Commands (in Claude Code chat)
 

package/cli/activity.mjs

@@ -188,7 +188,16 @@ export async function cmdActivity(db, args) {
       return;
     }
 
-    const result = db.prepare(`DELETE FROM events WHERE id IN (${placeholders})`).run(...ids);
+    // The opt-in search telemetry keeps a title per returned result; an explicit delete drops the
+    // deleted events' titles, as lib/delete-core.mjs does for observations (D#245 N6).
+    const result = db.transaction(() => {
+      if (db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'search_results'").get()) {
+        db.prepare(
+          `UPDATE search_results SET snapshot_label = NULL WHERE source = 'event' AND result_id IN (${placeholders})`,
+        ).run(...ids);
+      }
+      return db.prepare(`DELETE FROM events WHERE id IN (${placeholders})`).run(...ids);
+    })();
     out(`[mem] Deleted ${result.changes} event(s).`);
     return;
   }

package/haiku-client.mjs

@@ -20,6 +20,7 @@ import { randomUUID } from 'crypto';
 import { debugLog, debugCatch, parseJsonFromLLM } from './utils.mjs';
 import { DB_DIR } from './schema.mjs';
 import { resolveRuntimeDir } from './lib/resolve-data-dir.mjs';
+import { workerDirGone } from './lib/worker-data-dir.mjs';
 import { httpConnectProxyFor, postViaConnectProxy, postDirectHttp } from './lib/proxy-fetch.mjs';
 import { resolveAnthropicBaseUrl } from './lib/anthropic-base-url.mjs';
 
@@ -40,6 +41,9 @@ import { resolveAnthropicBaseUrl } from './lib/anthropic-base-url.mjs';
  */
 function cliSpawnCwd() {
   const dir = join(resolveRuntimeDir(DB_DIR), 'cli-cwd');
+  // A background worker whose data dir was removed during its API attempt must not re-create
+  // it here (D#265); the spawn then fails on the missing cwd, and the worker gives up.
+  if (workerDirGone(DB_DIR)) return dir;
   try {
     mkdirSync(dir, { recursive: true, mode: 0o700 });
   } catch {
@@ -555,8 +559,8 @@ async function callModelAPI(prompt, model, { timeout, maxTokens, temperature = D
     };
     // Plain http is loopback-only (resolveAnthropicBaseUrl), and loopback must stay on this
     // machine: native fetch would hand it, x-api-key in cleartext, to HTTP_PROXY under
-    // NODE_USE_ENV_PROXY=1. (D#250) Parsed, not a prefix test: the resolver accepts the scheme
-    // in any case (`HTTP://127.0.0.1`) and returns the raw text.
+    // NODE_USE_ENV_PROXY=1. (D#250) Parsed, not a prefix test: a prefix test let `HTTP://127.0.0.1`
+    // through to the proxy when the resolver still returned the raw text (b59e0cec, D#259).
     const plainHttp = new URL(apiUrl).protocol === 'http:';
     const send = (payload) => {
       const json = JSON.stringify(payload);

package/hook-optimize.mjs

@@ -485,7 +485,7 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       // A compression keeper is never hidden: hiding it hides every member compressed into it
       // (the same rule NOT_COMPRESSION_KEEPER_SQL enforces on the maintenance writers). It falls
       // through to the normal update instead: floored to importance 1 and stamped, so it is not
-      // re-sent. In narrow scope that update still replaces its title and narrative.
+      // re-sent. That update keeps its stored title and narrative in both scopes (keepStoredText).
       const isKeeper = !!db
         .prepare('SELECT 1 FROM observations WHERE compressed_into = ? LIMIT 1')
         .get(cand.id);
@@ -494,12 +494,8 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       const humanSet =
         (db.prepare('SELECT importance_set_at FROM observations WHERE id = ?').get(cand.id)
           ?.importance_set_at ?? null) !== null;
-      if (
-        (parsed.importance === 0 || parsed.importance === '0') &&
-        scope !== 'wide' &&
-        !isKeeper &&
-        !humanSet
-      ) {
+      const scoredZero = parsed.importance === 0 || parsed.importance === '0';
+      if (scoredZero && scope !== 'wide' && !isKeeper && !humanSet) {
         // D#12, and this one is not a stale-write guard — it is a POINTER guard.
         // `compressed_into` is the child -> keeper link, and COMPRESSED_AUTO is -1. If a
         // concurrent cluster-merge or smart-compress adopts this row during the 45 s Haiku
@@ -511,7 +507,8 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
         const res = db
           .prepare(
             `UPDATE observations SET compressed_into = ${COMPRESSED_AUTO}, optimized_at = ?
-             WHERE id = ? AND ${liveObsFilterSql('')} AND optimized_at IS NULL AND ${NOT_COMPRESSION_KEEPER_SQL}`,
+             WHERE id = ? AND ${liveObsFilterSql('')} AND optimized_at IS NULL AND ${NOT_COMPRESSION_KEEPER_SQL}
+               AND importance_set_at IS NULL`,
           )
           .run(Date.now(), cand.id);
         if (res.changes === 0) {
@@ -561,9 +558,15 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       // For `narrow`, the truncate stays on LLM output but NOT on the preserve-on-empty
       // fallback — truncating the row's own stored narrative to buy nothing was the same
       // bug in miniature.
+      //
+      // A reply that scored the row 0 reaches this point only for a row that may not be hidden
+      // (a compression keeper, or an importance a person set). It judged the row worthless, so
+      // its title and narrative do not replace the stored ones either (D#207: 'Weekly summary:
+      // auth refactor' became 'Weekly summary', narrative 'x').
       const isWide = scope === 'wide';
-      const title = isWide ? cand.title : truncate(scrubSecrets(parsed.title || ''), 120);
-      const narrative = isWide
+      const keepStoredText = isWide || scoredZero;
+      const title = keepStoredText ? cand.title : truncate(scrubSecrets(parsed.title || ''), 120);
+      const narrative = keepStoredText
         ? cand.narrative
         : parsed.narrative
           ? truncate(scrubSecrets(parsed.narrative), 500)
@@ -571,9 +574,10 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       // Floor at the stored importance: re-enrich adds a lesson, it must never silently downgrade
       // a user-set/promoted importance (the UPDATE also sets optimized_at → the loss is permanent).
       // Upgrades are still honored — except over an importance a person set (D10), which stays.
-      const importance = humanSet
-        ? cand.importance
-        : Math.max(clampImportance(parsed.importance), cand.importance || 1);
+      // Decided in the UPDATE itself, on the row as it is then: the candidate's importance was read
+      // before the model call, and writing it back undid a person's change made during the call
+      // (D#206).
+      const modelImportance = clampImportance(parsed.importance);
 
       const bigramText = cjkBigrams((title || '') + ' ' + (narrative || ''));
       const textField = [conceptsText, factsText, searchAliases || '', bigramText].filter(Boolean).join(' ');
@@ -607,10 +611,10 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
       // Narrow replaces title and narrative with model text, so an explicit save it rewrites (one
       // whose save-time enrich failed) moves to the re-enrich writer's id, as a cluster-merge
       // keeper does (D#146, D#138). Wide keeps the stored title and narrative (it fills the lesson
-      // and the side fields), so the row stays an explicit save. The writer's session row is
-      // best-effort.
+      // and the side fields), so the row stays an explicit save, and so does a row whose stored
+      // text a 0 reply left in place. The writer's session row is best-effort.
       let rewriteSessionId = null;
-      if (!isWide) {
+      if (!keepStoredText) {
         const cur = db.prepare('SELECT memory_session_id FROM observations WHERE id = ?').get(cand.id);
         if (cur?.memory_session_id?.startsWith(MANUAL_SESSION_ID_PREFIX)) {
           const enrichSessionId = writerSessionId('enrich-', cand.project);
@@ -629,7 +633,10 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
         .prepare(
           `
         UPDATE observations SET type=?, title=?, narrative=?, concepts=?, facts=?,
-          text=?, importance=?, lesson_learned=?, search_aliases=?, minhash_sig=?, optimized_at=?,
+          text=?,
+          importance = CASE WHEN importance_set_at IS NOT NULL THEN importance
+                            ELSE MAX(?, COALESCE(NULLIF(importance, 0), 1)) END,
+          lesson_learned=?, search_aliases=?, minhash_sig=?, optimized_at=?,
           scope=COALESCE(?, scope), memory_session_id = COALESCE(?, memory_session_id)
         WHERE id = ? AND ${liveObsFilterSql('')} AND optimized_at IS NULL
       `,
@@ -641,7 +648,7 @@ scope: ${SCOPE_PROMPT_LEGEND}`;
           safe.concepts,
           safe.facts,
           safe.text,
-          importance,
+          modelImportance,
           safe.lesson_learned,
           safe.search_aliases,
           minhashSig,
@@ -1300,6 +1307,8 @@ Return ONLY valid JSON:
     const bigramText = cjkBigrams((title || '') + ' ' + (narrative || ''));
     const textField = [conceptsText, factsText, bigramText].filter(Boolean).join(' ');
     const minhashSig = computeMinHash((title || '') + ' ' + (narrative || ''));
+    // An importance a person set on the keeper stays (D10); the UPDATE decides that on the row as
+    // it is then, since a person can set it while this call waits on the model (D#198).
     const importance = Math.max(clampImportance(parsed.importance || 2), maxClusterImportance);
 
     // Scrub LLM-output cluster-merge text fields at the UPDATE boundary.
@@ -1382,7 +1391,8 @@ Return ONLY valid JSON:
       db.prepare(
         `
         UPDATE observations SET title=?, narrative=?, concepts=?, facts=?, text=?,
-          importance=?, lesson_learned=?, minhash_sig=?, optimized_at=?,
+          importance = CASE WHEN importance_set_at IS NOT NULL THEN importance ELSE ? END,
+          lesson_learned=?, minhash_sig=?, optimized_at=?,
           memory_session_id = COALESCE(?, memory_session_id)
         WHERE id = ?
       `,

package/hook-shared.mjs

@@ -30,6 +30,7 @@ import {
 } from './lib/schema-skew.mjs';
 import { isDbUnusableError, DB_UNUSABLE_MARKER_PREFIX } from './lib/db-unusable.mjs';
 import { shouldRecordOnce } from './lib/record-once.mjs';
+import { backgroundWorkerEnv, workerDirGone } from './lib/worker-data-dir.mjs';
 import { hookSessionId } from './lib/provenance.mjs';
 import { PROJECT_REKEY_MARKER_PREFIX } from './lib/project-rekey.mjs';
 // Audit 2026-09-05 P1-2 (carried from 2026-09-02 P2-9): `callLLM`, the quiet/adoption
@@ -378,9 +379,11 @@ export function sweepStaleProjectMarkers(
 // exists, so harden here too: create 0700, and chmod a pre-existing dir a prior version
 // created at the default umask. A 0700 dir blocks traversal to every file inside,
 // current and future, regardless of individual file mode (audit sec P3-2 2026-07-24).
+// A background worker whose data dir was removed while it ran does not re-create it (D#265).
 try {
-  if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true, mode: 0o700 });
-  else chmodSync(RUNTIME_DIR, 0o700);
+  if (!existsSync(RUNTIME_DIR)) {
+    if (!workerDirGone(DB_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true, mode: 0o700 });
+  } else chmodSync(RUNTIME_DIR, 0o700);
 } catch {}
 
 // ─── Session ID Management ───────────────────────────────────────────────────
@@ -604,7 +607,7 @@ export function spawnBackground(bgEvent, ...extraArgs) {
     const child = spawn(process.execPath, args, {
       detached: true,
       stdio: 'ignore',
-      env: { ...process.env, CLAUDE_MEM_HOOK_RUNNING: '1' },
+      env: backgroundWorkerEnv(),
     });
     child.on('error', (err) => {
       debugCatch(err, 'spawnBackground');

package/hook-update.mjs

@@ -21,13 +21,14 @@ import {
 } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { tmpdir, homedir } from 'node:os';
+import { tmpdir } from 'node:os';
 // lib/data-paths.mjs, NOT schema.mjs: this module is what install.mjs::repair() imports to
 // reach the signature-verified release path, and schema.mjs statically imports
 // better-sqlite3 — so importing two path constants from there made the verified repair
 // unreachable on exactly the broken-install state it exists to repair (2026-09-08).
 // tests/repair-path-no-native-dep.test.mjs fails on any package edge reachable from here.
-import { DB_DIR, CODE_DIR } from './lib/data-paths.mjs';
+import { DB_DIR, CODE_DIR, claudeConfigDir, claudeStatePath } from './lib/data-paths.mjs';
+import { workerDirGone } from './lib/worker-data-dir.mjs';
 import { debugCatch, debugLog } from './utils.mjs';
 import { NATIVE_BINDING_SOURCE_BUILD_CMD } from './lib/binding-probe.mjs';
 // Local manifest is fallback only — the active manifest is loaded from the
@@ -41,7 +42,7 @@ import {
 // version check AND the release download — dies instantly behind a proxy, and
 // because checkForUpdate is silent on network failure the plugin then reports
 // itself permanently up to date. Same tunnel the OpenRouter call site uses.
-import { httpConnectProxyFor, getViaConnectProxy } from './lib/proxy-fetch.mjs';
+import { httpConnectProxyFor, getViaConnectProxy, redactProxyUrl } from './lib/proxy-fetch.mjs';
 import { acquireLock } from './lib/proc-lock.mjs';
 import { atomicWriteFileSync } from './lib/atomic-write.mjs';
 import { verifyReleaseFiles, verifyManifestSignature } from './lib/release-digest.mjs';
@@ -97,15 +98,25 @@ export async function checkForUpdate(options = {}) {
       return null;
     }
 
-    const latest = await fetchLatestRelease();
+    const lookup = await lookupLatestRelease();
+    const latest = lookup.release;
     if (!latest) {
-      // Re-read from disk: a 403 inside fetchWithTimeout just persisted rateLimited:true.
+      // Re-read from disk: a 403 inside fetchJson just persisted rateLimited:true.
       // Spreading the stale in-memory `state` (captured above with rateLimited:false) would
       // clobber that flag back to false, so shouldCheck never honors the backoff and the
       // rate-limit mechanism is dead. Re-reading preserves the freshly-written flag.
+      // lookupError / lookupFailingSince are doctor's evidence: lastCheck alone advanced on a
+      // failed lookup too, so doctor printed a fresh "last check" in green while every lookup
+      // behind a proxy failed from 2026-08-19 to 2026-10-07 (D#255). A success clears both.
       const fresh = readState();
-      saveState({ ...fresh, lastCheck: new Date().toISOString() });
-      return failed(lastLookupRateLimited);
+      const now = new Date().toISOString();
+      saveState({
+        ...fresh,
+        lastCheck: now,
+        lookupError: lookup.error,
+        lookupFailingSince: fresh.lookupFailingSince || now,
+      });
+      return failed(lookup.rateLimited);
     }
 
     const currentVersion = getCurrentVersion();
@@ -145,6 +156,8 @@ export async function checkForUpdate(options = {}) {
       updateAvailable: false,
       rateLimited: false,
       lastError: null,
+      lookupError: null,
+      lookupFailingSince: null,
     });
     return null;
   } catch (err) {
@@ -304,64 +317,94 @@ function shouldCheck(state) {
 
 // ── GitHub API ─────────────────────────────────────────────
 // Try releases/latest first, fallback to tags (some repos only use tags)
-// Whether the most recent fetchLatestRelease call was refused with 403/429. The persisted
-// `rateLimited` flag is not that: only a successful lookup clears it, so reading it after a
-// network failure blamed a rate limit from an earlier call. (pre-tag review of cd9f1ab7)
-let lastLookupRateLimited = false;
-
 export async function fetchLatestRelease() {
-  lastLookupRateLimited = false;
+  return (await lookupLatestRelease()).release;
+}
+
+// One lookup's outcome, returned rather than kept in module state: a module flag let a second
+// lookup running at the same time read the first one's 403 (D#260). `rateLimited` is THIS
+// lookup's refusal; the persisted flag is not that, since only a successful lookup clears it
+// (pre-tag review of cd9f1ab7). `error` says why there is no release, for doctor (D#255).
+async function lookupLatestRelease() {
   const headers = {
     Accept: 'application/vnd.github+json',
     'User-Agent': 'claude-mem-lite-updater/1.0',
   };
+  const fail = (rateLimited, error) => ({ release: null, rateLimited, error });
 
   // Attempt 1: GitHub Releases API
-  const result = await fetchWithTimeout(
-    `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`,
-    headers,
-  );
-  if (result === 'rate-limited') return null;
+  const result = await fetchJson(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, headers);
+  if (result.rateLimited) return fail(true, result.error);
   // Guard tag_name: a 200-OK with a malformed body ({} / {tag_name:null}) would throw
   // `Cannot read properties of undefined (reading 'replace')`. Caught upstream, but it
   // poisons lastError and blocks the tags fallback below — fall through instead.
-  if (result && typeof result.tag_name === 'string') {
+  const rel = result.body;
+  if (rel && typeof rel.tag_name === 'string') {
     return {
-      version: result.tag_name.replace(/^v/, ''),
-      tarballUrl: result.tarball_url,
-      releaseUrl: result.html_url,
-      assets: Array.isArray(result.assets) ? result.assets : [],
+      release: {
+        version: rel.tag_name.replace(/^v/, ''),
+        tarballUrl: rel.tarball_url,
+        releaseUrl: rel.html_url,
+        assets: Array.isArray(rel.assets) ? rel.assets : [],
+      },
+      rateLimited: false,
+      error: null,
     };
   }
 
   // Attempt 2: Tags API fallback (for repos without formal releases)
-  const tags = await fetchWithTimeout(`https://api.github.com/repos/${GITHUB_REPO}/tags?per_page=1`, headers);
-  if (tags === 'rate-limited') return null;
-  if (Array.isArray(tags) && tags.length > 0 && typeof tags[0]?.name === 'string') {
-    const tag = tags[0];
+  const tags = await fetchJson(`https://api.github.com/repos/${GITHUB_REPO}/tags?per_page=1`, headers);
+  if (tags.rateLimited) return fail(true, tags.error);
+  const tagList = tags.body;
+  if (Array.isArray(tagList) && tagList.length > 0 && typeof tagList[0]?.name === 'string') {
+    const tag = tagList[0];
     return {
-      version: tag.name.replace(/^v/, ''),
-      tarballUrl: `https://api.github.com/repos/${GITHUB_REPO}/tarball/${tag.name}`,
-      releaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${tag.name}`,
-      assets: [],
+      release: {
+        version: tag.name.replace(/^v/, ''),
+        tarballUrl: `https://api.github.com/repos/${GITHUB_REPO}/tarball/${tag.name}`,
+        releaseUrl: `https://github.com/${GITHUB_REPO}/releases/tag/${tag.name}`,
+        assets: [],
+      },
+      rateLimited: false,
+      error: null,
     };
   }
 
-  return null;
+  const relErr = result.error || 'no release in the response';
+  const tagErr = tags.error || 'no tag in the response';
+  return fail(false, relErr === tagErr ? relErr : `${relErr}; tags: ${tagErr}`);
+}
+
+// Why a request produced no usable body, in words doctor can print: the status, or the
+// transport error's code (native fetch wraps it as `fetch failed` with the code on `cause`).
+// The proxy is named redacted — HTTP(S)_PROXY may carry user:pass@.
+// Total: it runs inside fetchJson's catch, and a throw there would reject the lookup the
+// background check relies on never rejecting.
+function describeLookupError(e, proxy) {
+  try {
+    const what =
+      e?.name === 'AbortError'
+        ? `timed out after ${FETCH_TIMEOUT_MS / 1000} s`
+        : String(e?.cause?.code || e?.code || e?.message || e || 'unknown error');
+    return `${what.slice(0, 160)}${proxy ? ` via proxy ${redactProxyUrl(proxy)}` : ''}`;
+  } catch {
+    return 'unknown error';
+  }
 }
 
-async function fetchWithTimeout(url, headers) {
+async function fetchJson(url, headers) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let proxy = null;
   try {
     // Proxy configured → CONNECT tunnel; otherwise native fetch, byte-for-byte
     // the previous behaviour. Both shapes expose { status, ok, json() }, and the
     // tunnel REJECTS on transport failure exactly as a failed fetch does, so the
-    // catch below still returns null and the caller still stays silent.
+    // catch below still yields no body and the caller still stays silent.
     // The AbortController above governs only the fetch branch; the tunnel takes
     // the same budget as an explicit argument and bounds the whole call with it
     // (redirect chain included). (pre-tag review NOTE 7)
-    const proxy = httpConnectProxyFor(url);
+    proxy = httpConnectProxyFor(url);
     const res = proxy
       ? await getViaConnectProxy(proxy, url, { headers, timeout: FETCH_TIMEOUT_MS })
       : await fetch(url, { signal: controller.signal, headers });
@@ -372,13 +415,15 @@ async function fetchWithTimeout(url, headers) {
       const state = readState();
       saveState({ ...state, rateLimited: true });
       debugLog('DEBUG', 'hook-update', 'GitHub API rate limited; will retry on the 6h rate-limit cadence');
-      lastLookupRateLimited = true;
-      return 'rate-limited';
+      return {
+        rateLimited: true,
+        error: describeLookupError({ message: `HTTP ${res.status} (rate limited)` }, proxy),
+      };
     }
-    if (!res.ok) return null;
-    return await res.json();
-  } catch {
-    return null;
+    if (!res.ok) return { error: describeLookupError({ message: `HTTP ${res.status}` }, proxy) };
+    return { body: await res.json() };
+  } catch (e) {
+    return { error: describeLookupError(e, proxy) };
   } finally {
     clearTimeout(timeout);
   }
@@ -1056,7 +1101,7 @@ export async function installExtractedRelease(sourceDir, targetDir = INSTALL_DIR
     // guard rejects. Failure is non-fatal — a stale entry is noisy, not broken, and must
     // never roll back an otherwise-good update.
     try {
-      const settingsPath = join(homedir(), '.claude', 'settings.json');
+      const settingsPath = join(claudeConfigDir(), 'settings.json');
       if (existsSync(settingsPath)) {
         const { pruneDanglingMemHooks } = await import('./lib/hook-prune.mjs');
         const before = JSON.parse(readFileSync(settingsPath, 'utf8'));
@@ -1085,7 +1130,7 @@ export async function installExtractedRelease(sourceDir, targetDir = INSTALL_DIR
     // server was deleted on every plugin update that re-synced a direct install.
     try {
       if (isPluginMode()) {
-        const claudeJsonPath = join(homedir(), '.claude.json');
+        const claudeJsonPath = claudeStatePath();
         const cfg = JSON.parse(readFileSync(claudeJsonPath, 'utf8'));
         let changed = false;
         for (const k of ['mem', 'mem-lite']) {
@@ -1180,7 +1225,7 @@ export async function syncDataDirFromCache(opts = {}) {
     let sourceDir = opts.sourceDir || null;
     if (!sourceDir) {
       const cacheBase =
-        opts.cacheBase || join(homedir(), '.claude', 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
+        opts.cacheBase || join(claudeConfigDir(), 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
       if (!existsSync(cacheBase)) return { synced: false, reason: 'no-cache' };
       const versions = readdirSync(cacheBase)
         .filter((n) => /^\d+\.\d+/.test(n))
@@ -1320,7 +1365,7 @@ function copyReleaseIntoStaging(
 // appearing in a serialized hooks block) so the two cannot disagree about whether
 // settings.json owns the hooks.
 function hasInstallManagedSettingsHooks() {
-  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  const settingsPath = join(claudeConfigDir(), 'settings.json');
   if (!existsSync(settingsPath)) return false;
   let s;
   try {
@@ -1362,7 +1407,7 @@ export function clearCacheHookResidue() {
   // status/doctor then see the shape of a healthy plugin-only install. Inlined
   // here for the same reason the rest of this function is (see header).
   if (!hasInstallManagedSettingsHooks()) return 0;
-  const cacheBase = join(homedir(), '.claude', 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
+  const cacheBase = join(claudeConfigDir(), 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
   if (!existsSync(cacheBase)) return 0;
   let cleared = 0;
   for (const ver of readdirSync(cacheBase)) {
@@ -1411,7 +1456,7 @@ function isSameDir(a, b) {
 }
 
 export function prunePluginCache() {
-  const cacheBase = join(homedir(), '.claude', 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
+  const cacheBase = join(claudeConfigDir(), 'plugins', 'cache', 'sdsrss', 'claude-mem-lite');
   if (!existsSync(cacheBase)) return 0;
 
   const entries = readdirSync(cacheBase)
@@ -1435,7 +1480,7 @@ export function prunePluginCache() {
   const runningRoot = process.env.CLAUDE_PLUGIN_ROOT;
   let recordedRoot = null;
   try {
-    recordedRoot = detectInstallShape({ home: homedir() }).activePluginVersion?.root || null;
+    recordedRoot = detectInstallShape().activePluginVersion?.root || null;
   } catch {
     /* best-effort — a failure here must not stop pruning entirely */
   }
@@ -1470,6 +1515,9 @@ function readState() {
 }
 
 function saveState(state) {
+  // The update-check worker runs this after its release lookup; a data dir removed meanwhile
+  // stays removed (D#265, pre-tag review).
+  if (workerDirGone(STATE_DIR)) return;
   try {
     const dir = join(STATE_DIR, 'runtime'); // runtime-dir:stays-put — mkdir for update-state.json above
     mkdirSync(dir, { recursive: true });

package/hook.mjs

@@ -240,6 +240,8 @@ async function loadCacheGuard() {
 import { SKIP_TOOLS, SKIP_PREFIXES } from './skip-tools.mjs';
 
 import { DAY_MS } from './lib/time-constants.mjs';
+import { workerDirGone } from './lib/worker-data-dir.mjs';
+import { claudeConfigDir } from './lib/data-paths.mjs';
 // Prevent recursive hooks from background claude -p calls
 // Background workers (llm-episode, llm-summary) are exempt — they're ours
 const event = process.argv[2];
@@ -273,7 +275,7 @@ const BG_EVENTS = new Set([
 // install.mjs already holds a parsed settings object when it asks, this process does not.
 function pluginDisabledHere() {
   try {
-    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const settingsPath = join(claudeConfigDir(), 'settings.json');
     return isPluginExplicitlyDisabled(JSON.parse(readFileSync(settingsPath, 'utf8')));
   } catch {
     // Missing or unparseable settings.json → not disabled. Fail OPEN: a corrupt file must
@@ -284,6 +286,9 @@ function pluginDisabledHere() {
 
 if (event && pluginDisabledHere()) process.exit(0);
 if (process.env.CLAUDE_MEM_HOOK_RUNNING && !BG_EVENTS.has(event)) process.exit(0);
+// A worker whose data dir was removed before it started does nothing: no LLM call, no network,
+// and no write that would re-create the dir (D#265).
+if (BG_EVENTS.has(event) && workerDirGone(DB_DIR)) process.exit(0);
 
 // Crash-safe: flush episode buffer on unexpected termination to prevent data loss
 // Uses flag-based approach to avoid calling file I/O inside signal handlers,