@pcircle/memesh 4.5.0 → 4.6.0

package/scripts/hooks/session-start.js

@@ -2,10 +2,9 @@
 
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
-import { homedir } from 'os';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
-import { existsSync, readFileSync, unlinkSync, rmSync, appendFileSync, chmodSync } from 'fs';
+import { existsSync, readFileSync, unlinkSync, mkdirSync, accessSync, constants as fsConstants } from 'fs';
 import {
   buildReferenceContext,
   ensurePrivateDir,
@@ -13,14 +12,25 @@ import {
   getMemeshDirFromDbPath,
   getProjectName,
   importFromPluginRoot,
-  isAgenticOrchestrationEnabled,
+  assembleTopologyBlock,
+  DEFAULT_TOPOLOGY_BUDGET,
+  SNIPPET_FETCH_CHARS,
+  TOPOLOGY_CANDIDATE_CAP,
   isTrustedForAutoContext,
+  parseEntityMetadata,
+  // Aliased: this file already has a local `const memeshDir` (a resolved
+  // db-path-derived directory string) — the helper here is the MEMESH_DIR/
+  // home resolver the update-check cache itself uses.
+  memeshDir as memeshHomeDir,
+  parseTaskState,
   readUpdateCheckCache,
   resolvePluginRoot,
   resolveSessionLimit,
-  tryRequireBetterSqlite,
+  taskStateLines,
+  taskStateName,
   writePrivateJson,
 } from './_shared.js';
+import { MemeshDatabase } from './_generated/sqlite.js';
 
 const require = createRequire(import.meta.url);
 
@@ -44,7 +54,6 @@ try {
 const dbPath = getDbPath();
 const memeshDir = getMemeshDirFromDbPath();
 const throttlePath = join(memeshDir, 'session-recalled-files.json');
-const nudgeFlagsDir = join(memeshDir, 'agent-nudge-flags');
 
 /**
  * Build the strong deprecation warning lines to prepend to the
@@ -194,7 +203,7 @@ function isStrictlyOlder(a, b) {
   return pa.tail < pb.tail;
 }
 
-function buildUpdateAvailableBanner(currentVersion, cache, channel) {
+function buildUpdateAvailableBanner(currentVersion, cache, getChannel) {
   if (!cache || cache.currentVersion !== currentVersion) return [];
   // Deprecation banner takes precedence — when set, it owns the
   // session-start real estate. Skip the soft banner so the user sees
@@ -217,7 +226,10 @@ function buildUpdateAvailableBanner(currentVersion, cache, channel) {
   // this user a banner today?"
   try {
     const fs = require('fs');
-    const dir = join(homedir(), '.memesh');
+    // memeshHomeDir(), not join(homedir(), '.memesh'): the throttle marker
+    // must sit next to the update-check cache it throttles when MEMESH_DIR
+    // is set (readUpdateCheckCache resolves its path with this same helper).
+    const dir = memeshHomeDir();
     try { ensurePrivateDir(dir); } catch { /* best-effort */ }
     const versionTag = /^[0-9A-Za-z.+-]+$/.test(currentVersion) ? currentVersion : 'unknown';
     const markerPath = join(dir, `last-update-banner.${versionTag}.lock`);
@@ -236,6 +248,13 @@ function buildUpdateAvailableBanner(currentVersion, cache, channel) {
     } catch { /* best-effort */ }
   } catch { /* best-effort */ }
 
+  // Channel detection spawns `npm root -g` (50-200ms) — resolve it only
+  // here, after every early return above has had its chance to suppress
+  // the banner. The guards fire on ~every session; the banner at most
+  // once per 24h.
+  let channel = 'unknown';
+  try { channel = getChannel(); } catch { /* best-effort */ }
+
   const lines = [
     '',
     `ℹ️  MeMesh update available: ${cache.latestVersion} (you're on ${currentVersion}).`,
@@ -243,7 +262,7 @@ function buildUpdateAvailableBanner(currentVersion, cache, channel) {
   if (channel === 'npm-global') {
     lines.push(`    Run: memesh update`);
   } else if (channel === 'plugin-marketplace') {
-    lines.push(`    Run: bash <plugin-root>/scripts/upgrade-plugin.sh   (or reinstall from /plugin UI)`);
+    lines.push(`    Run: memesh upgrade-plugin   (no CLI? npx @pcircle/memesh upgrade-plugin — or reinstall from /plugin UI)`);
   } else if (channel === 'source-checkout') {
     lines.push(`    Source checkout: \`git pull && npm install && npm run build\`.`);
   } else if (channel === 'npm-local') {
@@ -311,7 +330,9 @@ function spawnFreshUpdateCheck(installedVersion) {
     const cliPath = join(pluginRoot, 'dist/transports/cli/cli.js');
     if (!existsSync(cliPath)) return false;
     const fs = require('fs');
-    const dir = join(homedir(), '.memesh');
+    // memeshHomeDir(), not join(homedir(), '.memesh') — same reasoning as
+    // the banner marker above: marker and cache must share a directory.
+    const dir = memeshHomeDir();
     try { ensurePrivateDir(dir); } catch { /* best-effort */ }
     // Codex round 37: scope the throttle marker to the installed
     // version. The marker was machine-global, so a refresh started
@@ -430,6 +451,48 @@ function runPostBannerUpdateTasks() {
   }
 }
 
+/**
+ * Can the capture hooks actually write? Returns the offending path, or null.
+ *
+ * Probes the two things a capture hook needs and nothing else: the memesh
+ * directory has to exist and be writable, and where the database file already
+ * exists, that file has to be writable too. The second half matters on its
+ * own — a writable directory holding a read-only database is a state the old
+ * mkdir-only probe called healthy, and it is exactly what a botched `sudo`
+ * leaves behind.
+ *
+ * `accessSync(W_OK)` rather than opening a handle: this is the SessionStart
+ * hot path, and a read-write open would run the whole migration chain here
+ * just to answer a permissions question. It is one syscall and it fails in
+ * the same cases EACCES would.
+ *
+ * Deliberately not detected: a full disk. No cheap probe finds it, and
+ * claiming otherwise would be worse than the honest gap.
+ */
+function captureTargetUnwritable() {
+  try {
+    mkdirSync(memeshDir, { recursive: true });
+    accessSync(memeshDir, fsConstants.W_OK);
+  } catch {
+    return memeshDir;
+  }
+  // The WAL/SHM sidecars are probed too: an interrupted `sudo` run leaves a
+  // user-owned database next to root-owned `-wal`/`-shm` files, and SQLite
+  // then fails every write with EACCES while the db file itself probes
+  // writable — the most common botched-sudo residue, and exactly the state
+  // the db-file probe alone called healthy.
+  for (const suffix of ['', '-wal', '-shm']) {
+    const p = `${dbPath}${suffix}`;
+    if (!existsSync(p)) continue;
+    try {
+      accessSync(p, fsConstants.W_OK);
+    } catch {
+      return p;
+    }
+  }
+  return null;
+}
+
 /**
  * Build a "base message + optional deprecation banner" combined
  * single-line systemMessage payload. Keeps stdout a single JSON
@@ -451,8 +514,8 @@ function combineWithBanner(baseMessage) {
       if (deprecation.length > 0) {
         lines = deprecation;
       } else {
-        const channel = detectInstallChannelHook(pluginRoot);
-        lines = buildUpdateAvailableBanner(installedVersion, cache, channel);
+        lines = buildUpdateAvailableBanner(
+          installedVersion, cache, () => detectInstallChannelHook(pluginRoot));
       }
     }
   } catch {
@@ -466,6 +529,14 @@ let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', async () => {
+  // Hoisted above both try blocks: the recall-failure catch below must be
+  // able to lead with this warning too, or a capture-dead session that ALSO
+  // hits a recall error silently drops the more important half of the story.
+  let captureWarning = null;
+  const withCaptureWarning = (msg) => {
+    if (!captureWarning) return msg;
+    return `${captureWarning}\n${msg.replace(/^◉ MeMesh ready · /, '◉ MeMesh · ')}`;
+  };
   try {
     try {
     const data = JSON.parse(input);
@@ -479,38 +550,61 @@ process.stdin.on('end', async () => {
     } catch {
       // Non-critical
     }
-    try {
-      if (existsSync(nudgeFlagsDir)) {
-        rmSync(nudgeFlagsDir, { recursive: true, force: true });
-      }
-    } catch {
-      // Non-critical
-    }
+
+    // Every banner below this line is a PROMISE that memories will be saved,
+    // so check that it can be kept before making any of them.
+    //
+    // This probe used to live INSIDE the `!existsSync(dbPath)` branch below,
+    // which meant it only ever ran before the database existed — while the
+    // failure it detects has nothing to do with first runs. A `~/.memesh` that
+    // became unwritable later (permissions changed, a read-only mount, a
+    // directory that changed owner) produced the cheerful green count banner
+    // on every session, forever, while every capture hook failed with EACCES.
+    // Fixing the first-run case and leaving the steady-state case is how a
+    // detector ends up covering the one day the bug is least likely to happen.
+    // The warning does NOT return: this hook's other job is recall, which
+    // opens the database read-only and works fine on an unwritable target.
+    // Returning here turned "capture is off" into "your memory is gone" —
+    // every existing memory silently withheld exactly when the user needs
+    // the context to notice something is wrong. Warn, then keep reading.
+    const unwritable = captureTargetUnwritable();
+    // "ready" is a promise about capture — when the warning is present,
+    // withCaptureWarning (hoisted above) demotes it instead of contradicting
+    // it one line later.
+    captureWarning = unwritable
+      ? `◉ MeMesh cannot write to ${unwritable} — memories will NOT be saved this session (recall still works). Run 'memesh doctor'.`
+      : null;
 
     if (!existsSync(dbPath)) {
       // Combine deprecation banner (if any) into the same
       // systemMessage so stdout stays a single JSON document. Outer
       // finally runs runPostBannerUpdateTasks().
-      output(combineWithBanner('◉ MeMesh ready · no database yet, memories will be created as you work'));
+      // With no database there is nothing to recall either — the warning IS
+      // the whole truth, and "memories will be created as you work" would
+      // contradict it one line later.
+      output(combineWithBanner(captureWarning ?? '◉ MeMesh ready · no database yet, memories will be created as you work'));
       return;
     }
 
-    // Native module unavailable (typical for plugin-marketplace cache
-    // installs that ship without node_modules). Silently skip — the
-    // plugin's own MCP server runs via npx and a sibling registered
-    // copy of this hook (npm-global / dev path) supplies the summary.
-    const Database = tryRequireBetterSqlite();
-    if (!Database) return;
-    const db = new Database(dbPath, { readonly: true });
+    // `readOnly`, not `readonly`: node:sqlite ignores the lowercase spelling
+    // and hands back a WRITABLE handle. This hook only reads.
+    //
+    // No `journal_mode = WAL` here. Setting it is a write, so a read-only
+    // connection refuses it — and it was never doing anything: the mode is a
+    // property of the database file that the writing side already set, and a
+    // reader opens a WAL database perfectly well without asking for it.
+    const db = new MemeshDatabase(dbPath, { readOnly: true });
+    // Whether the noise-compression epilogue below should run at all —
+    // pre-read from this readonly handle before it closes. Defaults to
+    // true so any early exit still lets the epilogue's own throttle decide.
+    let noiseCompressDue = true;
     try {
-      db.pragma('journal_mode = WAL');
-
       // Check if tables exist (db may exist but be empty)
       const tableCheck = db.prepare(
         "SELECT name FROM sqlite_master WHERE type='table' AND name='entities'"
       ).get();
       if (!tableCheck) {
-        output(combineWithBanner('◉ MeMesh ready · database initialised but no memories stored yet'));
+        output(combineWithBanner(captureWarning ?? '◉ MeMesh ready · database initialised but no memories stored yet'));
         return;
       }
 
@@ -545,11 +639,10 @@ process.stdin.on('end', async () => {
       // Functions:
       //   - frequency: log(c+1) / log(max(maxAccess,1) + 1)  (matches frequencyScore)
       //   - recency:   exp(-(now - lastAccessed_days) / 30)  (matches recencyScore)
-      // SQLite >= 3.35 with -DSQLITE_ENABLE_MATH_FUNCTIONS provides exp/log;
-      // better-sqlite3 v8+ ships with this flag enabled by default. We probe
-      // once per process and fall back to the legacy linear/rational forms
-      // if a stripped-down build is detected, so ranking degrades gracefully
-      // rather than throwing.
+      // SQLite >= 3.35 with -DSQLITE_ENABLE_MATH_FUNCTIONS provides exp/log,
+      // which Node's bundled SQLite has. We probe once per process and fall
+      // back to the legacy linear/rational forms if a stripped-down build is
+      // detected, so ranking degrades gracefully rather than throwing.
       // Test-only seam: force the legacy linear/rational fallback so the
       // pre-math-functions code path is reachable in CI on builds where
       // exp/log ARE available. Production callers never set this.
@@ -567,7 +660,12 @@ process.stdin.on('end', async () => {
       // doesn't have confidence/access_count/last_accessed_at, so the
       // SELECT can't reference them. Build the column list to match
       // what the schema actually supports.
-      const baseCols = 'e.id, e.name, e.type, e.created_at, e.metadata';
+      // `title` is an ALTER-added column (UX-1) and gets the same
+      // legacy-schema guard as the scoring columns: a database that predates
+      // it must still produce an injection, falling back to the observation
+      // snippet for its display text.
+      const hasTitle = colNames.has('title');
+      const baseCols = `e.id, e.name, e.type,${hasTitle ? ' e.title,' : ''} e.created_at, e.metadata`;
       const scoringCols = hasScoringCols
         ? `, e.confidence, e.access_count, e.last_accessed_at`
         : '';
@@ -584,7 +682,7 @@ process.stdin.on('end', async () => {
             pool_stats AS (
               SELECT COALESCE(MAX(access_count), 0) AS max_access FROM pool
             )
-            SELECT p.id, p.name, p.type, p.created_at, p.metadata
+            SELECT p.id, p.name, p.type,${hasTitle ? ' p.title,' : ''} p.created_at, p.metadata
             FROM pool p, pool_stats s
             ORDER BY
               COALESCE(p.confidence, 1.0) * 0.2833
@@ -613,7 +711,19 @@ process.stdin.on('end', async () => {
         `JOIN tags t ON t.entity_id = e.id`,
         `WHERE t.tag = ? ${statusFilter}`,
       );
-      const projectEntities = db.prepare(projectQuery).all(projectTag, sessionLimit * 3)
+      // Over-fetch WIDE, then filter. The window used to be `sessionLimit * 3`
+      // and the trust filter ran after it — so a class of entity that ranks
+      // high can consume the entire window and leave nothing. That was not
+      // hypothetical: measured on a real graph, all 30 top-ranked rows were
+      // filtered out and the "project memory" section rendered empty while 92
+      // eligible entities sat below the cut. The filter is a JS predicate with
+      // one owner (`isTrustedForAutoContext`); rather than restate it as SQL
+      // and own it twice, the window is made wide enough that the filtered
+      // class cannot fill it. CANDIDATE_CAP bounds the work for a large graph.
+      // Shared with the briefing surface via the leaf, so the two sides'
+      // candidate windows cannot drift apart.
+      const CANDIDATE_CAP = TOPOLOGY_CANDIDATE_CAP;
+      const projectEntities = db.prepare(projectQuery).all(projectTag, CANDIDATE_CAP)
         .filter(entity => isTrustedForAutoContext(entity.metadata))
         .slice(0, sessionLimit);
 
@@ -622,7 +732,7 @@ process.stdin.on('end', async () => {
       // so rewrite to e.status for consistency.
       const recentWhere = hasStatus ? "WHERE e.status = 'active'" : '';
       const recentQuery = buildScoringQuery('', recentWhere);
-      const recentEntities = db.prepare(recentQuery).all(15)
+      const recentEntities = db.prepare(recentQuery).all(CANDIDATE_CAP)
         .filter(entity => isTrustedForAutoContext(entity.metadata))
         .slice(0, 5);
 
@@ -635,7 +745,7 @@ process.stdin.on('end', async () => {
       let lessonEntities = [];
       try {
         const lessonRows = db.prepare(`
-          SELECT DISTINCT e.id, e.name, e.type, e.metadata
+          SELECT DISTINCT e.id, e.name, e.type,${hasTitle ? ' e.title,' : ''} e.metadata
           FROM entities e
           JOIN tags t ON t.entity_id = e.id
           WHERE e.type = 'lesson_learned'
@@ -688,8 +798,9 @@ process.stdin.on('end', async () => {
       // stay far under that on purpose — session start should prime the
       // model, not consume its working context. Snippets are truncated per
       // observation and the whole block is hard-capped.
-      const MAX_SNIPPET = 160;
-      const MAX_CONTEXT_CHARS = 4000;
+      // The budget itself comes from the leaf (DEFAULT_TOPOLOGY_BUDGET) at
+      // the assembleTopologyBlock call — "the same block" depends on the two
+      // surfaces agreeing, so neither side restates the numbers.
 
       const memoryLines = [];
       try {
@@ -722,33 +833,59 @@ process.stdin.on('end', async () => {
             // later ones are refinements.
             if (snippets.has(row.entity_id)) continue;
             const text = String(row.content ?? '').replace(/\s+/g, ' ').trim();
-            if (text) snippets.set(row.entity_id, text.slice(0, MAX_SNIPPET));
+            // A few line-widths, not the exact line cap: the final cut is
+            // clip()'s, on a word boundary — a hard slice at the line cap
+            // would hand it a string with nothing left to trim and ship
+            // mid-word fragments again.
+            if (text) snippets.set(row.entity_id, text.slice(0, SNIPPET_FETCH_CHARS));
           }
         }
 
-        // Groups overlap by construction: a lesson tagged to this project
-        // is in lessonEntities AND projectEntities. Render each entity once,
-        // in the highest-priority group it belongs to, so the injected block
-        // doesn't spend the model's context repeating itself.
-        const rendered = new Set();
-        const renderGroup = (label, entities) => {
-          const fresh = entities.filter(e => !rendered.has(e.id));
-          if (fresh.length === 0) return;
-          memoryLines.push(label);
-          for (const e of fresh) {
-            rendered.add(e.id);
-            const snippet = snippets.get(e.id);
-            const type = e.type || 'memory';
-            memoryLines.push(
-              snippet ? `- ${e.name} (${type}): ${snippet}` : `- ${e.name} (${type})`
-            );
-          }
-          memoryLines.push('');
-        };
+        // "Where we left off" leads the block. It is the one memory a new
+        // session needs before any other: everything below is context for
+        // work, this IS the work. It is also the only line here a human
+        // (or an agent acting for one) stated on purpose — the rest is
+        // ranked, and ranking cannot know what you meant to do next.
+        //
+        // Read from metadata, not from the observation trail: observations
+        // are the CHANGE history, and picking "the current goal" out of them
+        // means guessing which line is newest. Metadata holds one answer.
+        const taskRow = db
+          .prepare('SELECT metadata FROM entities WHERE name = ?')
+          .get(taskStateName(projectName));
+        const stateLines = taskStateLines(
+          parseTaskState(parseEntityMetadata(taskRow?.metadata)),
+          projectName,
+        );
 
-        renderGroup('Lessons learned (avoid repeating these):', topLessons);
-        renderGroup(`Project memory for "${projectName}":`, projectEntities);
-        renderGroup('Recently active across projects:', recentEntities);
+        // The pools overlap by construction (a lesson tagged to this project
+        // is in lessonEntities AND projectEntities); the shared assembler
+        // dedupes across them in claim order, so a project-scoped row is
+        // never marked foreign by the cross-project recent pool, and the
+        // topology grouping decides where each one belongs. This mapping —
+        // raw row → TopologyEntity — is the only part this hook owns; the
+        // assembly order, the spacer discipline, the budget and the
+        // task-state exclusion live in the leaf, shared with `briefing`.
+        const toEntity = (e) => {
+          const meta = parseEntityMetadata(e.metadata);
+          return {
+            name: e.name,
+            type: e.type || 'memory',
+            title: e.title ?? null,
+            snippet: snippets.get(e.id) ?? null,
+            signalScore: meta && typeof meta.signal_score === 'number' ? meta.signal_score : null,
+          };
+        };
+        memoryLines.push(...assembleTopologyBlock(
+          stateLines,
+          [
+            { entities: topLessons.map(toEntity), foreign: false },
+            { entities: projectEntities.map(toEntity), foreign: false },
+            { entities: recentEntities.map(toEntity), foreign: true },
+          ],
+          projectName,
+          DEFAULT_TOPOLOGY_BUDGET,
+        ));
       } catch (err) {
         // Snippet enrichment is best-effort. A failure here must not stop
         // the banner or the session — but trace it, because a silent break
@@ -764,22 +901,10 @@ process.stdin.on('end', async () => {
         // attacker-influenced in the general case (anything the agent has
         // ever been told can end up in an observation), so it must be
         // delimited the same way on every injection path — not hand-rolled
-        // per hook.
-        //
-        // Truncate the LINES before wrapping, so the closing fence is never
-        // cut off — a dangling fence would let the tail of the block escape
-        // its delimiter.
-        const budgeted = [];
-        let used = 0;
-        for (const line of memoryLines) {
-          if (used + line.length + 1 > MAX_CONTEXT_CHARS) {
-            budgeted.push('… (truncated)');
-            break;
-          }
-          budgeted.push(line);
-          used += line.length + 1;
-        }
-        memoryContext = buildReferenceContext(budgeted);
+        // per hook. The lines arrive already budgeted — assembleTopologyBlock
+        // charges the task-state block and the sections against ONE ceiling
+        // and returns whole lines only, so the closing fence cannot be cut.
+        memoryContext = buildReferenceContext(memoryLines);
       }
 
       // --- Record injected entity IDs for recall effectiveness tracking ---
@@ -842,24 +967,6 @@ process.stdin.on('end', async () => {
         try { process.stderr.write(`[memesh session-start] sessions-write: ${err?.message || err}\n`); } catch {}
       }
 
-      // --- Agentic-orchestration mode (opt-in) ---
-      // Banner kept short. Telemetry write preserved for protocol validation.
-      if (isAgenticOrchestrationEnabled(process.env)) {
-        summary += '\n[AO opt-in: dispatch verifiable work as background agent · skill: agentic-orchestration]';
-        try {
-          const usagePath = join(homedir(), '.memesh', 'skill-usage.jsonl');
-          // Only { ts, event } — an earlier `payload: { cwd_hashed }` was never
-          // read by summariseSkillUsage (counts by event name only), so it was
-          // write-only privacy-adjacent data. Removed.
-          const line = JSON.stringify({
-            ts: new Date().toISOString(),
-            event: 'agentic_orchestration_banner_injected',
-          }) + '\n';
-          appendFileSync(usagePath, line);
-          try { chmodSync(usagePath, 0o600); } catch { /* non-POSIX */ }
-        } catch { /* swallow — telemetry must not break session-start */ }
-      }
-
       // Deprecation banner (security advisory) — surfaced even with the
       // short summary so flagged installs still warn on every session.
       let installedVersion = null;
@@ -877,19 +984,34 @@ process.stdin.on('end', async () => {
         if (deprecation.length > 0) {
           bannerLines = deprecation;
         } else {
-          let channel = 'unknown';
-          try {
-            const pluginRoot = resolvePluginRoot(import.meta.url);
-            channel = detectInstallChannelHook(pluginRoot);
-          } catch { /* best-effort */ }
-          bannerLines = buildUpdateAvailableBanner(installedVersion, updateCache, channel);
+          bannerLines = buildUpdateAvailableBanner(installedVersion, updateCache,
+            () => detectInstallChannelHook(resolvePluginRoot(import.meta.url)));
         }
       }
       const finalMessage = bannerLines.length > 0
         ? [...bannerLines.filter(l => l.length > 0), '', summary].join('\n')
         : summary;
 
-      output(finalMessage, memoryContext);
+      output(withCaptureWarning(finalMessage), memoryContext);
+
+      // Pre-read the noise-compression throttle on the handle we already
+      // hold. compressWeeklyNoise() re-checks under its own connection, but
+      // ~364/365 sessions are inside the 24h window — and the full path
+      // costs two dist module-graph imports plus a write-capable
+      // migration-chain open (WAL writer lock) that must stay off the
+      // SessionStart hot path. Missing table / any error ⇒ due (the full
+      // path owns schema creation).
+      noiseCompressDue = (() => {
+        try {
+          const row = db.prepare(
+            "SELECT value FROM memesh_metadata WHERE key = 'last_noise_compress_at'"
+          ).get();
+          if (!row) return true;
+          return Date.now() - new Date(row.value).getTime() >= 24 * 60 * 60 * 1000;
+        } catch {
+          return true;
+        }
+      })();
     } finally {
       db.close();
     }
@@ -897,6 +1019,7 @@ process.stdin.on('end', async () => {
     // Opens a separate read-write connection via the core module.
     // Throttled to once per 24h inside compressWeeklyNoise().
     try {
+      if (noiseCompressDue) {
       // F5: derive pluginRoot strictly from this file's location.
       // See `resolvePluginRoot` for the full reasoning.
       const pluginRoot = resolvePluginRoot(import.meta.url);
@@ -908,6 +1031,7 @@ process.stdin.on('end', async () => {
       } finally {
         dbMod.closeDatabase();
       }
+      }
     } catch (err) {
       // Non-critical — noise compression failed, will retry next session.
       // Trace because this catch previously hid an off-by-one regression
@@ -921,7 +1045,7 @@ process.stdin.on('end', async () => {
       // Hooks must never crash Claude Code — but report honestly.
       // Inner catch so the outer finally can still run the post-
       // banner update tasks even when the recall flow blew up.
-      console.log(JSON.stringify({ systemMessage: `MeMesh: memories not loaded this session (${err?.message || 'unknown error'}) — everything else works; run \`memesh doctor\` if this repeats.` }));
+      console.log(JSON.stringify({ systemMessage: withCaptureWarning(`MeMesh: memories not loaded this session (${err?.message || 'unknown error'}) — everything else works; run \`memesh doctor\` if this repeats.`) }));
     }
   } finally {
     // ── Auto-update + cache refresh ──────────────────────────────