claude-mem-lite 3.92.0 → 3.93.0

package/lib/plugin-key.mjs

@@ -0,0 +1,44 @@
+// lib/plugin-key.mjs — the plugin's identity in Claude Code's settings, and the one
+// predicate that reads it.
+//
+// Audit 2026-09-02 P2-7. `PLUGIN_KEY` and `isPluginExplicitlyDisabled` shipped twice in JS —
+// `hook.mjs` (which exits 0 on every event when the plugin is off) and `install.mjs` (which
+// reports it in `doctor`/`status` and branches on it during cleanup) — plus a third,
+// deliberate copy in `scripts/post-tool-use.sh`.
+//
+// What makes the duplication load-bearing rather than untidy: `install.mjs` writes hooks
+// DIRECTLY into `~/.claude/settings.json`, so turning the plugin off in the Claude UI does
+// not remove them. They keep firing, and this predicate is the only thing that makes
+// "disabled" mean disabled. A key that drifts on one side leaves the user with a plugin they
+// switched off and a hook set that never noticed.
+//
+// ZERO DEPENDENCIES: `hook.mjs` imports this at module scope on the hottest path in the
+// system, and the check runs before anything else can.
+//
+// The shell copy in `scripts/post-tool-use.sh` STAYS a copy and is not a defect. That path
+// is the ~5 ms bash pre-filter whose entire purpose is never reaching `node`, so it cannot
+// import anything; its own header documents the parity requirement and
+// `tests/post-tool-use-disabled.test.mjs` pins it. Two homes with a tested bridge is a
+// different thing from two homes and a comment.
+
+/** Marketplace this plugin is published under. */
+export const MARKETPLACE_KEY = 'sdsrss';
+
+/** The key Claude Code writes under `enabledPlugins` in `~/.claude/settings.json`. */
+export const PLUGIN_KEY = `claude-mem-lite@${MARKETPLACE_KEY}`;
+
+/**
+ * Whether the user has EXPLICITLY switched the plugin off.
+ *
+ * Strict `=== false`, not falsiness: an absent key means "never installed via the
+ * marketplace" (an npm-only install, which must keep working) and `true` means enabled.
+ * Only an explicit `false` is a decision to honour — treating absent as disabled would
+ * silently kill every direct-install user.
+ *
+ * @param {object|null|undefined} settings  Parsed ~/.claude/settings.json, or nullish when
+ *   it is missing or unreadable — which reads as NOT disabled, so an unparseable settings
+ *   file fails open rather than disabling the plugin the user is trying to use.
+ */
+export function isPluginExplicitlyDisabled(settings) {
+  return settings?.enabledPlugins?.[PLUGIN_KEY] === false;
+}

package/lib/registry-core.mjs

@@ -208,3 +208,51 @@ export async function enrichNamedResource(db, name, { confineTo, enrichResource,
   const { status, error } = await enrichResourceRow(db, row, { confineTo, enrichResource, env });
   return { status, name: row.name, error };
 }
+
+/**
+ * How a registry search hit should be invoked, and the path worth showing for it.
+ *
+ * Audit 2026-09-02 P2-6: this ran to ~15 lines in `mem-cli.mjs cmdRegistry` and again in
+ * `server.mjs mem_registry`, and the copies had already diverged on `portablePath`:
+ *
+ *   MCP   `isManaged ? toPortable(local_path) : ''`
+ *   CLI   `isManaged && local_path.startsWith(home) ? '~'+… : (local_path || '')`
+ *
+ * For a NON-managed resource the CLI therefore printed `Path: /home/<user>/…` — an absolute
+ * path, un-tilde'd, for a row whose `Use:` line is `Skill("x")` or `mem_use(name=…)` and
+ * never mentions the path at all. MCP printed nothing. The MCP behaviour is the one kept:
+ * the line carried no action for the reader and spelled out a home directory to do it.
+ *
+ * Returns DATA, not a rendered line. The two faces genuinely differ in dialect — the CLI
+ * indents four spaces and prints through `out()`, MCP indents two and emits Markdown bold —
+ * and collapsing that would replace a real duplicate with a formatting flag.
+ *
+ * @param {{name:string,type:string,local_path?:string,invocation_name?:string}} r
+ * @param {{home:string, managedPrefix:string}} ctx  `managedPrefix` is `<dataDir>/managed/`,
+ *   already including the trailing separator, so the caller owns CLAUDE_MEM_DIR resolution.
+ * @returns {{isManaged:boolean, portablePath:string, howToUse:string}}
+ */
+export function resourceUseHint(r, { home, managedPrefix }) {
+  const isManaged = Boolean(r.local_path && r.local_path.includes(managedPrefix));
+  const portablePath = isManaged
+    ? (r.local_path.startsWith(home) ? '~' + r.local_path.slice(home.length) : r.local_path)
+    : '';
+  const agentArg = r.type === 'agent' ? ', type="agent"' : '';
+
+  let howToUse;
+  if (isManaged) {
+    // Managed: Read(path) or mem_use — Skill() does not resolve managed resources.
+    // Agents always carry a complete .md path; only skills can be a directory, which
+    // resolves to its SKILL.md.
+    const resolvedPath = portablePath.endsWith('.md') ? portablePath : `${portablePath}/SKILL.md`;
+    howToUse = `Read("${resolvedPath}") or mem_use(name="${r.name}"${agentArg})`;
+  } else if (r.invocation_name) {
+    // Native plugin/user resource: invoke by its full invocation name.
+    howToUse = r.type === 'skill'
+      ? `Skill("${r.invocation_name}")`
+      : `Agent(subagent_type="${r.invocation_name}")`;
+  } else {
+    howToUse = `mem_use(name="${r.name}"${agentArg})`;
+  }
+  return { isManaged, portablePath, howToUse };
+}

package/lib/resolve-data-dir.mjs

@@ -82,3 +82,61 @@ export function resolveDataDir(raw) {
   }
   return containInTests(raw);
 }
+
+/**
+ * The runtime directory: episode buffers, per-session markers, cooldowns, hook telemetry.
+ *
+ * Audit 2026-09-02 P1-14. `CLAUDE_MEM_RUNTIME_DIR` was honoured by exactly the five
+ * standalone hook scripts and `scripts/hook-launcher.mjs`, and IGNORED by `hook-shared.mjs`
+ * (which `hook.mjs`, `server.mjs`, `hook-context.mjs` and `hook-episode.mjs` all take it
+ * from) and by `hook-optimize.mjs`. So setting it did not relocate the runtime dir — it
+ * SPLIT it: the `fyi` and `pretool` faces wrote markers to the override while `ups` and
+ * `keyctx` read them from the real one. A harness pointing the system at an isolated
+ * runtime got a half-isolated one, silently, with no error and no empty directory to
+ * notice.
+ *
+ * The audit's own suggestion was to delete the variable from the five scripts. Measured
+ * before copying it: it is load-bearing in ten test files, in `hook-launcher.mjs`, and in
+ * `experiment/lib/arms.mjs`, which uses it to keep an experiment arm off the real state.
+ * Removing it would have cost all of that to fix a split that one shared resolver fixes.
+ * The defect was never that the knob exists — it is that the rule for reading it had eight
+ * hand-written homes and two modules that had never heard of it.
+ *
+ * WHAT BELONGS BEHIND THIS RESOLVER, AND WHAT DELIBERATELY DOES NOT. The v3.93.0 pre-tag
+ * review found the first cut of P1-14 half-applied — `scripts/user-prompt-search.js`
+ * resolved its RUNTIME_DIR here and then built its cross-hook marker from
+ * `join(DB_DIR, 'runtime')` anyway, so under the override the `fyi` face wrote the SHARED
+ * marker to one directory while `pretool` wrote it to another. Four subsystems were split
+ * that way (marker + skill cooldown, hook-error telemetry, the metrics sink and its GC, and
+ * the native-binding breakage marker, which is the self-heal trigger). The rule that
+ * resolved them, stated so the next sweep does not overshoot:
+ *
+ *   MOVES with the override — state a HOOK writes and another component reads back:
+ *   cross-hook injected-ids markers, skill/pre-recall cooldowns, hook-error telemetry,
+ *   the native-binding breakage marker, `metrics/`, `ep-flush-*` / `pending-*` buffers,
+ *   the shadow-recommendation log.
+ *
+ *   STAYS under the data dir — state about the ONE REAL INSTALLATION: `install.lock`,
+ *   `update-state.json`, `swap-in-progress`, and the `.update-staging-*` /
+ *   `.update-backup-*` residue scan. These must NOT follow a per-harness override: the
+ *   lock exists to serialise concurrent installers, and two installers pointed at
+ *   different override directories would each take their own lock and both proceed.
+ *
+ * `tests/runtime-dir-single-home.test.mjs` sweeps for the defect FORM (a shipped module
+ * building `join(…, 'runtime')` itself) with the stays-put sites as a named allowlist, so
+ * moving one out of that list is a deliberate edit rather than an omission.
+ *
+ * @param {string} dataDir  An already-resolved data dir (from resolveDataDir).
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string} An absolute runtime directory.
+ */
+export function resolveRuntimeDir(dataDir, env = process.env) {
+  const raw = env.CLAUDE_MEM_RUNTIME_DIR;
+  // Same "falsy means default" rule as above. A relative override is NOT rejected the way
+  // CLAUDE_MEM_DIR is: this variable is set by test harnesses that predate that check, and
+  // turning a previously-working relative path into a throw would break isolation setups
+  // in order to enforce tidiness. It is resolved against cwd instead, so the value is at
+  // least absolute by the time anything writes to it.
+  if (raw === undefined || raw === null || raw === '') return join(dataDir, 'runtime');
+  return isAbsolute(raw) ? raw : resolve(raw);
+}

package/mem-cli.mjs

@@ -4,6 +4,7 @@
 
 import { homedir } from 'os';
 import { ensureDbWithWalRecovery, DB_PATH, DB_DIR, REGISTRY_DB_PATH } from './schema.mjs';
+import { resolveRuntimeDir } from './lib/resolve-data-dir.mjs';
 import { truncate, typeIcon, inferProject, scrubSecrets, COMPRESSED_PENDING_PURGE } from './utils.mjs';
 import { resolveProject } from './project-utils.mjs';
 // READ commands resolve the project DB-aware: a subdirectory whose own name holds no rows
@@ -17,11 +18,11 @@ import { resolveCliProject as cliProject } from './lib/cli-project.mjs';
 import { _resetVocabCache, vecTextForRow, vectorsEnabled } from './tfidf.mjs';
 import { reRankWithContext } from './search-scoring.mjs';
 import { searchObservationsHybrid } from './search-engine.mjs';
-import { fetchObsDetail, fetchPromptDetail, fetchEventDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, PROMPT_DETAIL_FIELDS, EVENT_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
+import { fetchObsDetail, fetchPromptDetail, fetchEventDetail, fetchSessionDetail, OBS_FIELDS, SESSION_DETAIL_FIELDS, PROMPT_DETAIL_FIELDS, EVENT_DETAIL_FIELDS, supersededNotice } from './lib/get-core.mjs';
 import { collectBrowseTiers, getActiveMemorySessionId, BROWSE_TIERS, BROWSE_TIER_LABELS } from './lib/browse-core.mjs';
 import { deepSearch, resolveDeepMode, shouldEscalateToDeep, autoDeepLlmReady } from './deep-search.mjs';
 import { ensureRegistryDb, collectRegistryStats, listResourcesRanked, formatRegistryListLine } from './registry.mjs';
-import { IMPORT_STRING_FIELDS, importResource, removeResource, reindexResources, enrichResourceRow, enrichImportedResources, enrichNamedResource, REGISTRY_CONFINE_ENV } from './lib/registry-core.mjs';
+import { IMPORT_STRING_FIELDS, importResource, removeResource, reindexResources, enrichResourceRow, enrichImportedResources, enrichNamedResource, REGISTRY_CONFINE_ENV, resourceUseHint } from './lib/registry-core.mjs';
 import { searchResources } from './registry-retriever.mjs';
 import { computeFunnel, formatFunnel, computeSweep, formatSweep, DEFAULT_SWEEP_FLOORS, DEFAULT_SWEEP_MARGINS } from './registry-recommend.mjs';
 import { selectCompressionCandidates, groupByProjectWeek, compressGroup } from './lib/compress-core.mjs';
@@ -56,7 +57,7 @@ import { CLI_PATH, CLI_INVOKE } from './cli-path.mjs';
 import { parseArgs, out, outVerbatim, fail, relativeTime, fmtDateShort, parseIdToken, formatProbeHints, rejectBareStringFlags, resolvePositionalAlias, suggestUnknownFlags, OBS_TIME_FIELDS, formatObsFieldValue, obsFieldLabel, formatPendingPurgeLine } from './cli/common.mjs';
 import { saveObservation, saveWithClosures, formatSupersedeSkipped, formatSupersededNote } from './lib/save-observation.mjs';
 import { normalizeScope, insertObservationVector, applyObsUpdate } from './lib/observation-write.mjs';
-import { EXPORT_COLUMNS_SQL } from './lib/export-columns.mjs';
+import { EXPORT_COLUMNS_SQL, buildExportWhere } from './lib/export-columns.mjs';
 import { recallByFile } from './lib/recall-core.mjs';
 import { fetchRecent, RECENT_MAX } from './lib/recent-core.mjs';
 import { resolveAnchorToken, formatAnchorError, resolveQueryAnchor, fetchRecentTimeline, fetchTimelineWindow } from './lib/timeline-core.mjs';
@@ -561,8 +562,7 @@ function renderObsRows(db, ids, requestedFields) {
 }
 
 function renderSessionRows(db, ids) {
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db.prepare(`SELECT * FROM session_summaries WHERE id IN (${placeholders}) ORDER BY created_at_epoch ASC`).all(...ids);
+  const rows = fetchSessionDetail(db, ids);
   if (rows.length === 0) return null;
   const parts = [];
   for (const r of rows) {
@@ -1248,7 +1248,7 @@ async function cmdStats(db, args) {
   // recorded in the last 24h. Surfaces silent breakage (DB corruption,
   // CC upstream field rename) that would otherwise stay invisible — the
   // failure mode that left code-graph's matcher bug undetected for 10 sessions.
-  const hookErrors24h = countRecentHookErrors(join(DB_DIR, 'runtime'), now - DAY_MS);
+  const hookErrors24h = countRecentHookErrors(resolveRuntimeDir(DB_DIR), now - DAY_MS);
 
   // M-9 (audit 2026-08-14): disk footprint — a "lite" store had accumulated 360MB of
   // pre-maintain snapshots against a 59MB DB with nothing reporting it. Cheap probes
@@ -1654,42 +1654,37 @@ function cmdExport(db, args) {
   // script (`export --to "$END" > backup.json`) with an unset `$END` would silently
   // write an empty backup and report success. Reject like cmdSearch does.
   if (rejectBareStringFlags(flags, ['project', 'type', 'from', 'to'])) return;
-  const wheres = [];
-  const params = [];
-  // --include-compressed: include compressed observations (aligned with MCP mem_export).
-  // Superseded rows are excluded either way; the flag only toggles the compressed half
-  // of the live-row pair (backup/export of tombstones is opt-in, retractions are not).
-  if (flags['include-compressed'] === true || flags['include-compressed'] === 'true') {
-    wheres.push('superseded_at IS NULL');
-  } else {
-    wheres.push(liveObsFilterSql(''));
-  }
-
+  // PARSE + VALIDATE here; the SQL predicate itself comes from buildExportWhere (P2-5),
+  // shared with server.mjs runExport. The split is deliberate: the CLI `fail()`s with a
+  // usage message where the MCP tool throws, and only this face has a stderr channel for
+  // the inverted-range note below.
   const project = flags.project ? resolveProject(db, flags.project) : null;
-  if (project) { wheres.push('project = ?'); params.push(project); }
   if (flags.type) {
     // Reject unknown types — silently returning [] for `--type bogus` looked like a
     // legitimate empty filter result, hiding the typo. Mirrors cmdSearch / cmdSave / cmdUpdate.
-    const validObsTypes = OBS_TYPE_SET;
-    if (!validObsTypes.has(flags.type)) {
-      fail(`[mem] Invalid --type "${flags.type}". Valid: ${[...validObsTypes].join(', ')}`);
+    if (!OBS_TYPE_SET.has(flags.type)) {
+      fail(`[mem] Invalid --type "${flags.type}". Valid: ${[...OBS_TYPE_SET].join(', ')}`);
       return;
     }
-    wheres.push('type = ?'); params.push(flags.type);
   }
   let exportFromEpoch = null;
   let exportToEpoch = null;
   if (flags.from) {
     exportFromEpoch = new Date(flags.from).getTime();
     if (isNaN(exportFromEpoch)) { fail(`[mem] Invalid --from date: "${flags.from}". Use YYYY-MM-DD or ISO 8601.`); return; }
-    wheres.push('created_at_epoch >= ?'); params.push(exportFromEpoch);
   }
   if (flags.to) {
     exportToEpoch = new Date(flags.to).getTime();
     if (isNaN(exportToEpoch)) { fail(`[mem] Invalid --to date: "${flags.to}". Use YYYY-MM-DD or ISO 8601.`); return; }
     if (/^\d{4}-\d{2}-\d{2}$/.test(flags.to)) exportToEpoch += DAY_MS - 1;
-    wheres.push('created_at_epoch <= ?'); params.push(exportToEpoch);
   }
+  // --include-compressed: include compressed observations (aligned with MCP mem_export).
+  // Superseded rows are excluded either way; the flag only toggles the compressed half
+  // of the live-row pair (backup/export of tombstones is opt-in, retractions are not).
+  const { wheres, params } = buildExportWhere({
+    includeCompressed: flags['include-compressed'] === true || flags['include-compressed'] === 'true',
+    project, type: flags.type || null, fromEpoch: exportFromEpoch, toEpoch: exportToEpoch,
+  });
   if (exportFromEpoch !== null && exportToEpoch !== null && exportFromEpoch > exportToEpoch) {
     process.stderr.write(`[mem] Note: --from "${flags.from}" is after --to "${flags.to}"; this range is empty\n`);
   }
@@ -2211,19 +2206,8 @@ function cmdRegistry(_memDb, args) {
       for (const r of results) {
         const badge = r.quality_tier === 'installed' ? '[✓]' : r.quality_tier === 'verified' ? '[★]' : '[○]';
         const categoryLabel = r.category ? ` [${r.category}]` : '';
-        const isManaged = r.local_path && r.local_path.includes(join(DB_DIR, 'managed') + sep);
-        const portablePath = isManaged && r.local_path.startsWith(home) ? '~' + r.local_path.slice(home.length) : (r.local_path || '');
-        let howToUse;
-        if (isManaged) {
-          const resolvedPath = portablePath.endsWith('.md') ? portablePath : `${portablePath}/SKILL.md`;
-          howToUse = `Read("${resolvedPath}") or mem_use(name="${r.name}"${r.type === 'agent' ? ', type="agent"' : ''})`;
-        } else if (r.invocation_name) {
-          howToUse = r.type === 'skill'
-            ? `Skill("${r.invocation_name}")`
-            : `Agent(subagent_type="${r.invocation_name}")`;
-        } else {
-          howToUse = `mem_use(name="${r.name}"${r.type === 'agent' ? ', type="agent"' : ''})`;
-        }
+        // P2-6: the invocation rule is shared; only the four-space indent is this face's.
+        const { portablePath, howToUse } = resourceUseHint(r, { home, managedPrefix: join(DB_DIR, 'managed') + sep });
         const pathLine = portablePath ? `\n    Path: ${portablePath}` : '';
         out(`  ${badge} ${r.type === 'skill' ? 'S' : 'A'} ${r.name}${categoryLabel} — ${truncate(r.capability_summary || '', 80)}${pathLine}\n    Use: ${howToUse}`);
       }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.92.0",
+  "version": "3.93.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "3.92.0",
+      "version": "3.93.0",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.26.0",
         "better-sqlite3": "^12.6.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "3.92.0",
+  "version": "3.93.0",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF 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).",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -87,6 +87,8 @@
     "lib/lesson-bridge.mjs",
     "lib/binding-probe.mjs",
     "lib/install-shape.mjs",
+    "lib/hook-stdin.mjs",
+    "lib/plugin-key.mjs",
     "lib/hook-stdout.mjs",
     "lib/proc-lock.mjs",
     "lib/atomic-write.mjs",

package/registry-recommend.mjs

@@ -7,7 +7,7 @@
 // `off` skips all work.
 import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, appendFileSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
-import { resolveDataDir } from './lib/resolve-data-dir.mjs';
+import { resolveDataDir, resolveRuntimeDir } from './lib/resolve-data-dir.mjs';
 import { searchResources, cjkIntentTokens } from './registry-retriever.mjs';
 
 import { DAY_MS } from './lib/time-constants.mjs';
@@ -57,7 +57,7 @@ const RECO_COOLDOWN_MS = 300_000;        // 5 min, mirrors T4 SKILL_COOLDOWN_MS
 // DB_DIR formula) so tests sandbox via env without ESM-cache gymnastics, and prod reads
 // the same dir as the rest of the app.
 function recoRuntimeDir() {
-  return join(resolveDataDir(process.env.CLAUDE_MEM_DIR), 'runtime');
+  return resolveRuntimeDir(resolveDataDir(process.env.CLAUDE_MEM_DIR));
 }
 
 const TOKEN_SPLIT = /[^a-z0-9一-鿿]+/;

package/schema.mjs

@@ -152,7 +152,12 @@ export const CODE_DIR = join(homedir(), '.claude-mem-lite');
 // (citation_surface_log.surface) in LATEST_MIGRATION_COLUMNS: a table that only
 // the forced pass can create is unreachable forever once the version row says
 // "done", which is not a hypothetical — see the note there.
-export const CURRENT_SCHEMA_VERSION = 46;
+// v47: two additive indexes (P2-11 + ALGO-7). The bump is LOAD-BEARING, not bookkeeping:
+// `initSchema`'s fast path returns before the `CREATE INDEX IF NOT EXISTS` block, so on
+// every existing install at v46 a new index there would simply never be created. Same trap
+// the FTS5 migration hit — a DDL change that is not reachable from the version the DB
+// already reports is a no-op with a convincing diff.
+export const CURRENT_SCHEMA_VERSION = 47;
 
 // Sentinel columns for the LATEST migration set(s). The fast-path uses these
 // to self-heal half-migrated DBs — schema_version bumped but column ALTERs
@@ -551,6 +556,18 @@ export function initSchema(db) {
   db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sdk_sessions(project)`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_not_compressed ON observations(created_at_epoch DESC) WHERE COALESCE(compressed_into, 0) = 0`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_handoffs_project_time ON session_handoffs(project, type, created_at_epoch DESC)`);
+  // v47 (audit 2026-09-02 P2-11 + the previous round's ALGO-7), one additive migration for
+  // both. Additive only: new indexes on existing columns, no table rewrite, no data move.
+  //
+  // The first was the ONLY genuine full table scan in the 30 statements the audit ran
+  // through EXPLAIN QUERY PLAN. Stop and SessionStart both probe "does a summary exist for
+  // this memory session?", `session_summaries` is 10,160 rows here, and the cost grows
+  // linearly with the table for a question asked on every hook event.
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_sess_sum_memory_session ON session_summaries(memory_session_id)`);
+  // The second narrows the live-row scan the injection faces run per project. Partial on the
+  // same predicate `liveObsFilterSql` uses, so the index covers exactly the rows those
+  // queries can return.
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_project_live ON observations(project, created_at_epoch DESC) WHERE superseded_at IS NULL AND COALESCE(compressed_into, 0) = 0`);
 
   // FTS5 migration: recreate observations_fts when columns are missing (one-time)
   // Detect old FTS5 table missing lesson_learned or search_aliases and recreate with full column set

package/scripts/hook-launcher.mjs

@@ -66,6 +66,16 @@ const BROKEN_MARKER = join(RUNTIME_DIR, 'hook-launcher-broken');
 // Marker dir mirrors the standalone hook scripts (pre-tool-recall /
 // pre-skill-bridge), which honor CLAUDE_MEM_RUNTIME_DIR — they write 78 of every
 // 79 of these markers, so reading a different dir would mean never healing.
+// The last hand-written copy of this rule, and it stays: this launcher runs BEFORE the
+// native binding is known to work, so it imports only `node:` builtins on purpose — even
+// `lib/resolve-data-dir.mjs` is a module resolution it declines to make on the path whose
+// job is to survive a broken install. `lib/resolve-data-dir.mjs::resolveRuntimeDir` is the
+// canonical rule (audit 2026-09-02 P1-14). It is NOT identical to it, and saying so was
+// wrong: the resolver additionally makes a RELATIVE override absolute (`isAbsolute(raw) ?
+// raw : resolve(raw)`), while this expression hands the relative value straight to `fs`,
+// which resolves it against cwd at call time instead of at module load. They agree on
+// unset, on empty and on an absolute override — the three cases that reach a real install.
+// Keep the DEFAULTING behaviour in step; do not read "identical" into the difference.
 const NB_RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || RUNTIME_DIR;
 const NB_BROKEN_MARKER = join(NB_RUNTIME_DIR, 'native-binding-broken');
 const NB_HEAL_MARKER = join(NB_RUNTIME_DIR, 'native-binding-lastheal');

package/scripts/post-tool-recall.js

@@ -20,19 +20,21 @@
 
 import { existsSync, readFileSync } from 'fs';
 import { basename, join } from 'path';
-import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
+import { resolveDataDir, resolveRuntimeDir } from '../lib/resolve-data-dir.mjs';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
 // D#154: every envelope on this stdout goes through the one writer. This script has a
 // single emit today, so the change buys nothing on its own — it buys that a SECOND
 // emit added later merges instead of producing two JSON documents, which the host
 // parses as neither (lib/hook-stdout.mjs). Import-free module over no runtime deps.
 import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
+// P1-9: one bounded stdin reader. Import-free, like hook-stdout.mjs beside it.
+import { readHookStdin, TOOL_INPUT_FILE_MAX_BYTES } from '../lib/hook-stdin.mjs';
 import { cooldownPathFor as sharedCooldownPathFor } from '../lib/cooldown-path.mjs';
 
 const SALIENCE_BIND = process.env.CLAUDE_MEM_SALIENCE === 'bind';
 
 const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
-const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
+const RUNTIME_DIR = resolveRuntimeDir(DATA_DIR);
 const LEGACY_COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
 
 // The no-session legacy fallback stays local: it is this script's own back-compat with
@@ -46,8 +48,9 @@ function cooldownPathFor(sessionId) {
 async function main() {
   if (!SALIENCE_BIND) return;
   if (process.env.CLAUDE_MEM_HOOK_RUNNING) return;
-  let input = '';
-  for await (const chunk of process.stdin) input += chunk;
+  // Bounded stdin (P1-9) — was an unbounded `for await` accumulate with no cap or timeout.
+  // Same payload class as pre-tool-recall: a PostToolUse on `Write` carries the whole file.
+  const { text: input } = await readHookStdin({ maxBytes: TOOL_INPUT_FILE_MAX_BYTES });
   let filePath, sessionId;
   try {
     const e = JSON.parse(input);

package/scripts/pre-agent-inject.js

@@ -22,16 +22,24 @@ const ENABLED = process.env.CLAUDE_MEM_SUBAGENT_INJECT === 'on'
 // 2026-08-14 M-5). Swallows everything: telemetry must never break a dispatch.
 async function recordFailure(scope, err, ctx) {
   try {
-    const [{ recordHookError }, { resolveDataDir }, { join }] = await Promise.all([
+    const [{ recordHookError }, { resolveDataDir, resolveRuntimeDir }] = await Promise.all([
       import('../lib/hook-telemetry.mjs'),
       import('../lib/resolve-data-dir.mjs'),
-      import('path'),
     ]);
-    const dataDir = resolveDataDir(process.env.CLAUDE_MEM_DIR);
-    recordHookError(scope, err, process.env.CLAUDE_MEM_RUNTIME_DIR || join(dataDir, 'runtime'), ctx);
+    // P1-14: the shared resolver, not a fourth hand-written `env || join(...)`. This is on
+    // the error path, which already dynamic-imports, so the script's zero-import budget on
+    // the HAPPY path is untouched.
+    recordHookError(scope, err, resolveRuntimeDir(resolveDataDir(process.env.CLAUDE_MEM_DIR)), ctx);
   } catch { /* never */ }
 }
 
+// The ONE hand-written stdin reader left in the tree, and it stays deliberately (P1-9).
+// The other five now share `lib/hook-stdin.mjs`; this script is the default-OFF path whose
+// entire reason to exist is costing nothing when the feature is disabled, and it reaches
+// this line before importing anything at all — even an import-free module is a module
+// resolution. Its caliber (1.5 s, 262144, never rejects) is the same shape the shared
+// reader implements with `rejectOnTimeout: false`, so if this ever gains an import, delete
+// this function and call `readHookStdin({ timeoutMs: 1500, maxBytes: 262144 })`.
 function readStdin() {
   return new Promise((resolve) => {
     let data = '';

package/scripts/pre-skill-bridge.js

@@ -7,17 +7,20 @@ import { existsSync, readFileSync } from 'fs';
 import { join, resolve, sep } from 'path';
 import { homedir } from 'os';
 import { recordHookError } from '../lib/hook-telemetry.mjs';
-import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
+import { resolveDataDir, resolveRuntimeDir } from '../lib/resolve-data-dir.mjs';
 // format-utils.mjs is import-free — pulling three defang helpers keeps this script
 // inside its "lightweight standalone" budget (no heavy transitive deps).
 import { neutralizeContextDelimiters, neutralizeSkillDelimiters, neutralizeSkillBridgeDelimiters } from '../format-utils.mjs';
 // D#154: single envelope writer. Also import-free (no runtime deps), so it stays
 // inside this script's "lightweight standalone" budget.
 import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
+// P1-9: bounded stdin. Also import-free, so it stays inside the "lightweight standalone"
+// budget this script's header claims.
+import { readHookStdin } from '../lib/hook-stdin.mjs';
 
 // CLAUDE_MEM_DIR mirrors pre-tool-recall.js — one env var sandboxes everything.
 const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
-const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
+const RUNTIME_DIR = resolveRuntimeDir(DATA_DIR);
 // D#29: all data artifacts follow DATA_DIR (CLAUDE_MEM_DIR-aware), not a hardcoded
 // homedir — previously REGISTRY_DB_PATH/MANAGED_BASE/MARKER pinned homedir while line 12
 // honored the env, so relocated installs opened the wrong DB and the marker never matched
@@ -32,9 +35,10 @@ try {
   // Skip if recursive hook
   if (process.env.CLAUDE_MEM_HOOK_RUNNING) process.exit(0);
 
-  // Read stdin
-  let input = '';
-  for await (const chunk of process.stdin) input += chunk;
+  // Read stdin, bounded (P1-9). This used to be an unbounded `for await` accumulate: no
+  // cap, no timeout, the only limit being the host's own fail-open — which looks exactly
+  // like the hook having nothing to say.
+  const { text: input } = await readHookStdin();
 
   // Parse event
   let skillName;

package/scripts/pre-tool-recall.js

@@ -6,7 +6,7 @@
 
 import { existsSync, readFileSync, mkdirSync } from 'fs';
 import { basename, join } from 'path';
-import { resolveDataDir } from '../lib/resolve-data-dir.mjs';
+import { resolveDataDir, resolveRuntimeDir } from '../lib/resolve-data-dir.mjs';
 import { atomicWriteFileSync } from '../lib/atomic-write.mjs';
 import { injectedIdsFileName, injectedIdKey, EVENT_ID_PREFIX, readInjectedMarker, mergeInjectedMarker } from '../lib/injected-ids.mjs';
 import { liveObsFilterSql } from '../lib/inject-search-core.mjs';
@@ -39,6 +39,8 @@ import { neutralizeContextDelimiters } from '../format-utils.mjs';
 //
 // Import-free module, no runtime deps — nothing added to this script's load cost.
 import { queueHookContext, flushHookStdout } from '../lib/hook-stdout.mjs';
+// P1-9: one bounded stdin reader. Import-free, like hook-stdout.mjs beside it.
+import { readHookStdin, TOOL_INPUT_FILE_MAX_BYTES, salvageTruncatedHookEvent } from '../lib/hook-stdin.mjs';
 // Recall queries the SAVE-path project, so this MUST produce the same string as the
 // save path. It used to be a hand-kept copy of the same 6 lines; that copy had already
 // drifted once (missing the process.env.PWD fallback, so a symlinked project dir
@@ -53,7 +55,8 @@ import { DAY_MS } from '../lib/time-constants.mjs';
 // per-component overrides for tests that mix isolated + real paths.
 const DATA_DIR = resolveDataDir(process.env.CLAUDE_MEM_DIR);
 const DB_PATH = process.env.CLAUDE_MEM_DB_PATH || join(DATA_DIR, 'claude-mem-lite.db');
-const RUNTIME_DIR = process.env.CLAUDE_MEM_RUNTIME_DIR || join(DATA_DIR, 'runtime');
+const RUNTIME_DIR = resolveRuntimeDir(DATA_DIR);
+
 // A3 (v2.83): cross-hook dedup window. UPS writes
 // `runtime/.claude-mem-injected-<project>` after each inject; we read it to drop IDs the
 // agent already saw in this window. Imported, not inlined (ARCH-3): the copy's stated
@@ -301,9 +304,25 @@ try {
   // Skip if DB doesn't exist
   if (!existsSync(DB_PATH)) process.exit(0);
 
-  // Read stdin
-  let input = '';
-  for await (const chunk of process.stdin) input += chunk;
+  // Read stdin, bounded (P1-9), at THIS path's own caliber — not the module default.
+  //
+  // A first cut called `readHookStdin()` bare, taking the 256 KB default, and justified it
+  // by saying a truncated payload "is what the host's 3 s fail-open did anyway". That was
+  // measured at the v3.93.0 pre-tag review and is FALSE: `JSON.parse` of a 5 MB payload
+  // takes 2.99 ms and 10 MB takes 10.8 ms — three orders of magnitude inside the fail-open,
+  // so the old unbounded read was not timing out, it was working. The cap did not make an
+  // existing loss deliberate, it CREATED one, on `pretool` — the highest-cite-rate injection
+  // face this project measures. This repo's own CHANGELOG.md is 1 MB, so a `Write` to it
+  // crossed the default cap and silently lost the recall while logging a hook error.
+  //
+  // Two changes, because they cover different halves. The cap is now a MEMORY backstop
+  // sized to the payload class (a whole file), not a functional gate. And a truncated read
+  // is salvaged rather than dropped, the same way `hook.mjs handlePostToolUse` salvages
+  // `tool_name` from a truncated prefix: everything below needs `file_path` / `tool_name` /
+  // `session_id`, all of which are scalars the host emits alongside `content`. Salvage is
+  // strictly better than the previous behaviour — when the prefix does not carry them we
+  // land exactly where the drop landed.
+  const { text: input, truncated } = await readHookStdin({ maxBytes: TOOL_INPUT_FILE_MAX_BYTES });
 
   // Parse event
   let filePath;
@@ -323,8 +342,17 @@ try {
     const lim = event.tool_input?.limit;
     isFullRead = (off === undefined || off === null) && (lim === undefined || lim === null);
   } catch (e) {
-    recordHookError('pre-recall:json', e, RUNTIME_DIR, { inputLen: input.length });
-    process.exit(0);
+    const salvaged = truncated ? salvageTruncatedHookEvent(input) : null;
+    if (!salvaged) {
+      // A genuinely malformed payload. Kept distinct from the truncation case above so the
+      // hook-error log that `stats` and `doctor` read as an install-health signal does not
+      // fill with rows for perfectly normal large writes.
+      recordHookError('pre-recall:json', e, RUNTIME_DIR, { inputLen: input.length, truncated });
+      process.exit(0);
+    }
+    ({ filePath, sessionId, toolName } = salvaged);
+    toolInput = {};
+    isFullRead = true;
   }
 
   // Upstream-shape probe: hook ran but neither field nor input shape matches the