ai-lens 0.8.114 → 0.8.117

package/.commithash

@@ -1 +1 @@
-507ff10
+28976f3

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 History of changes to the `ai-lens` CLI package on npm. New entries go on top. Format: `## X.Y.Z — YYYY-MM-DD`, followed by user-facing bullets.
 
+## 0.8.117 — 2026-07-01
+- fix(team-memory): never inject team memory in projects outside your `projects` filter — an unrelated repo now gets nothing, even if it's on your machine
+
+## 0.8.116 — 2026-07-01
+- fix(team-memory): only inject memory that is genuinely relevant to your prompt — a vague or off-topic prompt now injects nothing, instead of dumping arbitrary team conventions
+
+## 0.8.115 — 2026-07-01
+- feat(team-memory): inject relevant team memory per prompt (matched to what you're asking) instead of a blind dump at session start
+- feat(team-memory): injected memory carries a hint to report it as wrong/outdated via the `ai_lens_memory_report_wrong` MCP tool
+- feat(cli): `ai-lens memory on|off|status` — control team-memory injection on your machine
+
 ## 0.8.114 — 2026-07-01
 - fix(client): normalize Windows /c:/ drive paths so Cursor git metadata is captured
 - feat(team-memory): SessionStart recall + injection (T6)

package/bin/ai-lens.js

@@ -38,6 +38,11 @@ switch (command) {
     await deleteSessions();
     break;
   }
+  case 'memory': {
+    const { default: memory } = await import('../cli/memory.js');
+    await memory();
+    break;
+  }
   case 'local-server':
   case 'install-local-server': {
     // `install-local-server` is an alias that always means `local-server up`.
@@ -89,6 +94,7 @@ switch (command) {
     console.log('    --days N --source S --limit N --json');
     console.log('  delete-sessions  Delete your own sessions (dry-run unless --yes)');
     console.log('    <id…> | --from D --to D [--source S] [--days N] [--yes] [--json]');
+    console.log('  memory <on|off|status>  Toggle per-prompt team-memory injection on your machine');
     console.log('  local-server <up|down|status>  Run a private local server in Docker (your data stays local)');
     console.log('    up [--port N] [--yes] [--recreate]   Bring it up, then offer to point the client at it');
     console.log('    down [--purge]                       Stop it (--purge also deletes the data volume)');

package/cli/memory.js

@@ -0,0 +1,47 @@
+/**
+ * `ai-lens memory <on|off|status>` — per-person team-memory opt-out (T6d [0118]).
+ *
+ * Privacy-first + client-side: opting out is a local flag file (MEMORY_OPT_OUT_PATH)
+ * — the dev decides on their own machine. When set:
+ *   - capture.js renders NO per-prompt memory inject and writes NO match annotation;
+ *   - sender.js sends `X-Memory-Opt-Out: 1` so the server stops PRIMING the cache.
+ * `on` = memory injection ON (removes the flag). `off` = opt out (writes the flag).
+ * No server round-trip, no auth needed.
+ */
+
+import { existsSync, writeFileSync, unlinkSync } from 'node:fs';
+import { ensureDataDir, MEMORY_OPT_OUT_PATH, MEMORY_INDEX_PATH } from '../client/config.js';
+
+function isOptedOut() {
+  try { return existsSync(MEMORY_OPT_OUT_PATH); } catch { return false; }
+}
+
+export default async function memory() {
+  const sub = (process.argv[3] || 'status').toLowerCase();
+
+  if (sub === 'on' || sub === 'enable') {
+    // Opt back IN: remove the flag file. (The server resumes priming on the next POST.)
+    try { unlinkSync(MEMORY_OPT_OUT_PATH); } catch { /* already absent */ }
+    console.log('AI Lens team memory: ON — relevant team memories will be surfaced on your prompts.');
+    return;
+  }
+
+  if (sub === 'off' || sub === 'disable') {
+    ensureDataDir();
+    try {
+      writeFileSync(MEMORY_OPT_OUT_PATH, new Date().toISOString() + '\n');
+    } catch (err) {
+      console.error(`Could not write opt-out flag: ${err.message}`);
+      process.exit(1);
+    }
+    // Drop the primed cache immediately so no stale inject can fire before TTL.
+    try { unlinkSync(MEMORY_INDEX_PATH); } catch { /* already absent */ }
+    console.log('AI Lens team memory: OFF — no memories will be injected into your prompts.');
+    console.log('Re-enable any time with `ai-lens memory on`.');
+    return;
+  }
+
+  // status (default)
+  console.log(`AI Lens team memory: ${isOptedOut() ? 'OFF (opted out)' : 'ON'}`);
+  console.log('Usage: ai-lens memory <on|off|status>');
+}

package/client/capture.js

@@ -35,9 +35,38 @@ import {
   NODE_NUDGE_SHOWN_PATH,
   MEMORY_INDEX_PATH,
   MEMORY_INDEX_SHOWN_PATH,
+  SESSION_MEMORY_SHOWN_DIR,
+  MEMORY_OPT_OUT_PATH,
 } from './config.js';
 import { isLockStale, isSenderBackoffActive } from './sender.js';
 import { toNumberOrNull, buildTokenUsageRaw } from './token-usage.js';
+// Soft import — memory-messages.js (i18n seam for the injected report-wrong hint,
+// RU default) ships alongside this file by installClientFiles, but a partial/
+// corrupted copy or version skew must NOT take down capture with ERR_MODULE_NOT_FOUND
+// (mirrors memory-match/redact/mojibake-fix below). On a miss, memoryMsg → '' and the
+// hint LINE is omitted (renderPromptInject guards on falsy) — hooks survive, report
+// hint goes dark. Standalone client copy — the hook can't import server code; keep RU
+// copy in sync with server/lib/memory-messages.js.
+let memoryMsg = () => '';
+try {
+  const mod = await import('./memory-messages.js');
+  memoryMsg = mod.t ?? (() => '');
+} catch { /* partial install — report hint disabled, hooks survive */ }
+// Soft import — memory-match.js is shipped alongside this file by installClientFiles
+// (dynamic client/*.js discovery COPIES it atomically with capture.js — verified), so
+// on a normal install this branch always resolves; the try/catch is belt-not-trousers
+// for a corrupted/partial install or version skew, never the prod path. A missing/
+// broken module → no-op scorer (never ERR_MODULE_NOT_FOUND, never a half-broken
+// scorer: a missing export falls back to () => [], a call-time throw is caught inside
+// maybeEmitUserPromptMemoryInject). DEGRADED SYMPTOM (silent, by design — a per-hook
+// log would spam every prompt): repo-specific BM25 matches go dark, but team-general
+// (phase-1) still injects since it does NOT depend on the scorer. If per-prompt repo
+// matches ever vanish org-wide, suspect a partial client install here first.
+let scoreCandidates = () => [];
+try {
+  const mod = await import('./memory-match.js');
+  scoreCandidates = mod.scoreCandidates ?? (() => []);
+} catch { /* corrupted/partial install — repo matches disabled, team-general survives */ }
 // Soft import — redact.js may not exist on older client installs
 let redactObject = (o) => o;
 try {
@@ -1692,6 +1721,217 @@ export function maybeEmitSessionStartMemoryIndex(primary, { now = Date.now() } =
   } catch { return false; } // never break capture
 }
 
+// =============================================================================
+// Team-memory PER-PROMPT inject (T6d [0118]) — query-aware, LOCAL BM25 match.
+//
+// SessionStart is now a PRIME ONLY: the server ships a candidate POOL (both tiers,
+// with preview + repo_rel_paths) which sender.js caches to MEMORY_INDEX_PATH. This
+// helper — on each UserPromptSubmit — scores the CURRENT prompt against that pool
+// locally (the server's recall can't see this prompt in time; its response is a
+// prompt behind) and injects only the memories that cross the relevance threshold.
+//   phase-1 (first prompt): top repo matches + team-general (always apt);
+//   phase-N: only NEW/unshown crossings (surgical re-inject).
+// Two gating axes: eligibility (server only primes for treatment ∧ not opt-out →
+// empty cache ⇒ this is a no-op) and relevance (local BM25 threshold).
+// =============================================================================
+
+// Relevance floor for the local BM25 scorer. Below this a candidate never surfaces.
+// PROVISIONAL, UNCALIBRATED — a starting guess to be tuned live on analytics ([0118]).
+// Measured band on realistic pairs (see test/client/memory-match.test.js): a single
+// on-topic term ("iceberg") ~2.2; a 2-word on-topic prompt 3–4; a generic dev prompt
+// sharing ONE weak word with a memory preview lands ~1.2–1.4 (just under) — so 1.5
+// currently suppresses single-generic-word overlaps while passing 2+ on-topic-word
+// matches. That margin is THIN (a 0.1–0.2 shift flips borderline prompts), which is
+// exactly why the number is deferred to live tuning, not treated as final. Bounded
+// blast radius (budget below + phase-N unshown-gate) keeps a mis-tuned floor from
+// flooding — worst case is 1–2 extra short memories, never a dump.
+// Calibrated on live prod pairs (analytics pilot, 2026-07): genuine matches score
+// ≫3 (specific-term prompts hit 3–13), noise clusters at 1.5–2.0. 3.0 cleanly
+// separates them — precision over recall BY DESIGN: silence beats a context-rotting
+// near-miss. Tunable down with PostHog match data if it proves too quiet.
+const MEMORY_MATCH_MIN_SCORE = 3.0;
+// Budget: never inject more than this many memories per prompt (repo OR team-general
+// alike) — keeps a prompt light even on a broad match.
+const MEMORY_INJECT_BUDGET = 2;
+const MEMORY_INJECT_MAX_LEN = 1500;
+const MEMORY_INJECT_HEADER = 'AI Lens team memory — relevant to this prompt (full text via ai_lens_memory_read):';
+// Bound the per-session shown-set (safety valve; sessions are naturally bounded).
+const MEMORY_SHOWN_SET_MAX = 200;
+
+function sessionMemoryShownPath(sessionId) {
+  return join(SESSION_MEMORY_SHOWN_DIR, encodeURIComponent(sessionId || 'unknown'));
+}
+
+/** Read the per-session shown-set (`{ <mem_id>: iso, __count: n }`). Never throws. */
+function readSessionShown(sessionId) {
+  const map = readJsonFileSafe(sessionMemoryShownPath(sessionId));
+  return map && typeof map === 'object' ? map : {};
+}
+
+/**
+ * Atomically persist the per-session shown-set (tmp+rename). Best-effort.
+ *
+ * CONCURRENCY: this is a read-modify-write with last-writer-wins on the whole map
+ * (the tmp+rename is atomic per WRITE — no torn file — but two overlapping capture
+ * processes for the SAME session_id can lose an update: both read __count=0, both
+ * fire phase-1, both write __count=1). Accepted, NOT locked: a UserPromptSubmit is a
+ * single human submitting a single prompt in a single conversation, and session_id
+ * is per-conversation — so concurrent same-session UserPrompts are architecturally
+ * implausible (subagents don't emit UserPromptSubmit; two IDE windows = two
+ * session_ids). Worst case in the implausible burst = a team-general memory shown
+ * twice or one memory re-injected once — bounded by the budget, non-corrupting. A
+ * lockfile would add a new failure mode to a best-effort cosmetic path for a race
+ * that can't occur in real single-user use.
+ */
+function writeSessionShown(sessionId, map) {
+  try {
+    // Ensure the shown-set dir exists (self-heal if it was never mkdir'd — e.g. an
+    // old data dir predating T6d). ensureDataDir mkdirs SESSION_MEMORY_SHOWN_DIR.
+    ensureDataDir();
+    // Bound growth: if too many mem ids accumulate, drop the oldest by iso.
+    const ids = Object.keys(map).filter(k => !k.startsWith('__'));
+    if (ids.length > MEMORY_SHOWN_SET_MAX) {
+      ids.sort((a, b) => (Date.parse(map[a]) || 0) - (Date.parse(map[b]) || 0))
+        .slice(0, ids.length - MEMORY_SHOWN_SET_MAX)
+        .forEach(k => delete map[k]);
+    }
+    const p = sessionMemoryShownPath(sessionId);
+    const tmp = p + '.tmp.' + process.pid;
+    writeFileSync(tmp, JSON.stringify(map));
+    renameSync(tmp, p);
+  } catch { /* best-effort */ }
+}
+
+/**
+ * Render selected candidates to a compact block: title + preview + the pull pointer.
+ * Length-bounded + control-char-sanitized (defense-in-depth; preview is server text).
+ * Pure. Returns '' when nothing renderable.
+ */
+function renderPromptInject(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return '';
+  const lines = [MEMORY_INJECT_HEADER];
+  for (const e of entries) {
+    if (!e || !e.id) continue;
+    const title = typeof e.title === 'string' ? e.title.replace(/\s+/g, ' ').trim() : '';
+    lines.push(`- ${title || e.id}`);
+    const preview = typeof e.preview === 'string' ? e.preview.replace(/\s+/g, ' ').trim() : '';
+    if (preview) lines.push(`  ${preview}`);
+    lines.push(`  full text: ai_lens_memory_read('${e.id}')`);
+    // T8 [0110] report-wrong: point the agent at the report tool with this entry's
+    // id (i18n; RU default). Only on the per-prompt inject (NOT the SessionStart
+    // index, which stays id+title-only). Length is bounded by MEMORY_INJECT_MAX_LEN.
+    // OMIT the line entirely when the message is empty (soft-import miss / unknown
+    // key → memoryMsg returns '') — never push a blank half-rendered line.
+    const hint = memoryMsg('inject_report_hint', { id: e.id });
+    if (hint) lines.push(`  ${hint}`);
+  }
+  if (lines.length === 1) return '';
+  return sanitizeMessageText(lines.join('\n').slice(0, MEMORY_INJECT_MAX_LEN));
+}
+
+/**
+ * On a UserPromptSubmit, locally score the prompt against the primed candidate pool
+ * and inject the relevant memories via capture's one stdout write. Claude →
+ * `systemMessage`; Cursor → `additional_context` (+ relay suffix). Codex/unknown →
+ * no-op (parity with the SessionStart inject). Reads only local caches → identity-
+ * independent; never throws → can't flip capture's exit code.
+ *
+ * Returns `{ wrote, match }` where `match` (or null) is the metadata the caller
+ * stamps onto the queued event as `data.memory_match` so the SERVER can emit
+ * `memory_matched`. `match` carries IDS + SCALARS only — never the prompt text.
+ *
+ * @param {object} primary  the normalized UserPromptSubmit event
+ * @returns {{wrote:boolean, match:null|{matched_ids:string[],top_score:number,prompt_index:number,n_matched:number,had_team_general:boolean}}}
+ */
+export function maybeEmitUserPromptMemoryInject(primary, { now = Date.now() } = {}) {
+  const NONE = { wrote: false, match: null };
+  try {
+    if (!primary || primary.type !== 'UserPromptSubmit') return NONE;
+    const source = primary.source;
+    if (source !== 'claude_code' && source !== 'cursor') return NONE; // codex/unknown deferred
+
+    // Per-person opt-out (client-side, privacy-first): no render, no annotation.
+    if (existsSync(MEMORY_OPT_OUT_PATH)) return NONE;
+
+    // Respect the projects filter. The primed pool is machine-GLOBAL, but a match
+    // must NOT surface in an UNTRACKED project — an unrelated repo the user doesn't
+    // monitor for AI Lens (e.g. a GPU/ASR build that has nothing to do with the team).
+    // This mirrors the project_filter drop the caller applies to event shipping; it
+    // just runs earlier here because the inject is emitted BEFORE that drop. No filter
+    // / no project_path → monitored (inject allowed — unchanged for single-project users).
+    if (!isProjectMonitored(primary.project_path, primary.workspace_roots, getMonitoredProjects())) return NONE;
+
+    // Load the primed pool. Empty/absent cache = not eligible (server only primes
+    // for treatment ∧ not opt-out) ⇒ this is a clean no-op. Also enforce the same
+    // freshness TTL the SessionStart render used (an offline client must not match
+    // against a week-old pool forever).
+    const cache = readJsonFileSafe(MEMORY_INDEX_PATH);
+    const entries = cache && Array.isArray(cache.entries) ? cache.entries : null;
+    if (!entries || entries.length === 0) return NONE;
+    const updatedAtMs = cache.updatedAt ? Date.parse(cache.updatedAt) : NaN;
+    if (!Number.isFinite(updatedAtMs) || now - updatedAtMs > MEMORY_INDEX_MAX_AGE_MS) return NONE;
+
+    const promptText = primary.data && typeof primary.data.prompt === 'string' ? primary.data.prompt : '';
+
+    // Phase index: __count advances on EVERY UserPrompt (even a silent no-inject),
+    // so phase-1 = truly the FIRST prompt of the session, not the first inject.
+    const shown = readSessionShown(primary.session_id);
+    const promptIndex = Number.isFinite(shown.__count) ? shown.__count : 0;
+
+    // Always advance the phase counter for this prompt before any early return below,
+    // and persist it — so a silent prompt still moves phase-1 → phase-N.
+    const nowIso = new Date(now).toISOString();
+    const commitCount = () => { shown.__count = promptIndex + 1; writeSessionShown(primary.session_id, shown); };
+
+    if (!promptText) { commitCount(); return NONE; }
+
+    // Score with the local BM25-lite scorer over the whole pool.
+    const scored = scoreCandidates(promptText, entries);
+    const byId = new Map(entries.map(e => [e.id, e]));
+    const scoreOf = new Map(scored.map(s => [s.id, s.score]));
+
+    // Relevance-gated selection (UNIFORM across phases): inject ONLY candidates —
+    // repo OR team-general — that clear MEMORY_MATCH_MIN_SCORE for THIS prompt and
+    // were not already shown this session. NO unconditional team-general dump: a
+    // low-signal prompt ("давай делай", "continue") scores ~0 → injects NOTHING.
+    // Precision over recall BY DESIGN — silence beats context-rot. `promptIndex`
+    // still advances via commitCount() for telemetry, but no longer gates selection.
+    const picked = scored
+      .filter(s => s.score >= MEMORY_MATCH_MIN_SCORE && !shown[s.id])
+      .map(s => byId.get(s.id))
+      .filter(Boolean)
+      .slice(0, MEMORY_INJECT_BUDGET);
+    const hadTeamGeneral = picked.some(e => e && e.delivery === 'team');
+
+    if (picked.length === 0) { commitCount(); return NONE; }
+
+    const text = renderPromptInject(picked);
+    if (!text) { commitCount(); return NONE; }
+
+    const out = source === 'claude_code'
+      ? { systemMessage: text }
+      : { additional_context: text + CURSOR_RELAY_SUFFIX };
+    process.stdout.write(JSON.stringify(out));
+
+    // Record the injected ids in the shown-set AND advance the phase counter (once).
+    for (const e of picked) shown[e.id] = nowIso;
+    commitCount();
+
+    const matchedIds = picked.map(e => e.id);
+    const topScore = matchedIds.reduce((m, id) => Math.max(m, scoreOf.get(id) || 0), 0);
+    return {
+      wrote: true,
+      match: {
+        matched_ids: matchedIds,
+        top_score: topScore,
+        prompt_index: promptIndex,
+        n_matched: matchedIds.length,
+        had_team_general: hadTeamGeneral,
+      },
+    };
+  } catch { return NONE; } // never break capture
+}
+
 // Weekly throttle for the Node-upgrade nudge below (its own stamp file).
 const NODE_NUDGE_THROTTLE_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -1797,17 +2037,31 @@ async function main() {
   // hook invocation on the same machine.
   const primary = events[0];
 
-  // Render a server-driven update nudge ([0093]) on SessionStart — BEFORE the
-  // project_filter / no_email / dedup gates below (those drop exactly the
-  // stale/unknown devs we want to reach). Identity-independent, reads only the
-  // local cache, never throws → can't flip this process to a non-zero exit.
-  // capture.js makes exactly ONE stdout write per invocation, so these share the
-  // slot via a priority chain (each helper writes at most once): the server-driven
-  // [0093] message wins, else the team-memory index (T6 [0108], treatment cohort),
-  // else the local Node-upgrade nudge (Cursor sessions on Node < 22.5).
-  if (!maybeEmitSessionStartMessage(primary)
-      && !maybeEmitSessionStartMemoryIndex(primary)) {
-    maybeEmitNodeUpgradeNudge(primary);
+  // Single-stdout slot — BEFORE the project_filter / no_email / dedup gates below
+  // (those drop exactly the stale/unknown devs we want to reach). Identity-
+  // independent, reads only local caches, never throws → can't flip this process to
+  // a non-zero exit. capture.js makes exactly ONE stdout write per invocation.
+  //
+  // The two branches are keyed on the primary event TYPE and are mutually exclusive
+  // (a hook invocation is EITHER a SessionStart OR a UserPromptSubmit, never both),
+  // so they never contend for the one write:
+  //   - SessionStart → the [0093] server nudge (wins), else the local Node-upgrade
+  //     nudge. NOTE (T6d [0118]): SessionStart is now PRIME-ONLY for team memory —
+  //     the T6 blind-index render (maybeEmitSessionStartMemoryIndex) is intentionally
+  //     no longer called from here; memory injection moved to the UserPrompt branch.
+  //     (The function + its tests are kept, revivable; its git_remote-null throttle
+  //     quirk is moot now that it isn't wired in.)
+  //   - UserPromptSubmit → the query-aware per-prompt team-memory inject (T6d),
+  //     which also returns match metadata we stamp onto the queued event below so
+  //     the server can emit `memory_matched`.
+  let userPromptMemoryMatch = null;
+  if (primary.type === 'SessionStart') {
+    if (!maybeEmitSessionStartMessage(primary)) {
+      maybeEmitNodeUpgradeNudge(primary);
+    }
+  } else if (primary.type === 'UserPromptSubmit') {
+    const r = maybeEmitUserPromptMemoryInject(primary);
+    userPromptMemoryMatch = r.match;
   }
 
   // Filter by monitored projects (if configured) — based on the primary event.
@@ -1846,6 +2100,16 @@ async function main() {
   // Attach git metadata once — every event in the batch shares it.
   const gitMeta = getGitMetadata(primary.project_path);
 
+  // T6d [0118]: stamp the local per-prompt match onto the primary event's data so
+  // the SERVER emits `memory_matched` on ingest. Placed BEFORE writeToSpool (below)
+  // so it's persisted, and AFTER event_id-independent so it never perturbs the
+  // deterministic event_id (that's hashed from raw stdin, not from data). METADATA
+  // ONLY — ids + scalars, never the prompt text (bright line).
+  if (userPromptMemoryMatch && primary.type === 'UserPromptSubmit') {
+    primary.data = primary.data || {};
+    primary.data.memory_match = userPromptMemoryMatch;
+  }
+
   // Assign event_ids:
   //   - Primary: deterministic from stdin hash (so Cursor + Claude Code firing
   //     the same hook compute the same id and dedup at ON CONFLICT).

package/client/config.js

@@ -38,6 +38,17 @@ export const NODE_NUDGE_SHOWN_PATH = join(DATA_DIR, 'node-nudge-shown');
 // throttle, so a dev re-opening sessions doesn't suppress the adoption funnel.
 export const MEMORY_INDEX_PATH = join(DATA_DIR, 'memory-index.json');
 export const MEMORY_INDEX_SHOWN_PATH = join(DATA_DIR, 'memory-index-shown.json');
+// Query-aware per-prompt memory injection (T6d [0118]): the per-session shown-set
+// (one file per session, `{ <mem_id>: iso, __count: n }`) records which memories
+// have been injected in a session so phase-N re-injects only NEW/unshown crossings
+// (pattern of SESSION_PATHS_DIR — per-session file, no shared-state race), and
+// `__count` advances on EVERY UserPrompt so phase-1 = truly the first prompt.
+export const SESSION_MEMORY_SHOWN_DIR = join(DATA_DIR, 'session-memory-shown');
+// Per-person opt-out (privacy-first, CLIENT-side): presence of this file = the dev
+// opted out of memory injection. Read by capture.js (no render/annotation) AND by
+// sender.js (sends `X-Memory-Opt-Out: 1` so the server stops PRIMING the cache).
+// Toggled by `ai-lens memory on|off`. Absence = opted in (the treatment default).
+export const MEMORY_OPT_OUT_PATH = join(DATA_DIR, 'memory-opt-out');
 export const LOG_MAX_AGE_DAYS = 30;
 const GIT_ROOT_CACHE = new Map();
 // Pipe stderr (instead of inheriting it) so that "fatal: not a git repository"
@@ -104,6 +115,7 @@ export function ensureDataDir() {
   mkdirSync(SESSION_PATHS_DIR,  { recursive: true });
   mkdirSync(TRANSCRIPT_OFFSETS_DIR, { recursive: true });
   mkdirSync(GIT_REMOTES_DIR,    { recursive: true });
+  mkdirSync(SESSION_MEMORY_SHOWN_DIR, { recursive: true });
 }
 
 export function getServerUrl() {

package/client/memory-match.js

@@ -0,0 +1,162 @@
+/**
+ * BM25-lite local scorer — query-aware per-prompt memory matching (T6d [0118]).
+ *
+ * WHY LOCAL (not a server call): the UserPromptSubmit hook must emit its inject
+ * into the CURRENT prompt synchronously (stdout is read into THIS turn), but the
+ * server's piggyback recall response arrives a prompt LATER. So the client can't
+ * ask the server "what matches THIS prompt" in time — it must score the current
+ * prompt against the already-primed candidate pool locally, here.
+ *
+ * Self-contained by necessity: the client ships via npm to developer machines, so
+ * this must have ZERO runtime deps (no `natural`, no tokenizer package). ~1 file,
+ * pure functions, deterministic — fully unit-testable without I/O.
+ *
+ * The corpus is the SMALL primed pool (cap ~30 candidates), so this is BM25 with a
+ * tiny-corpus caveat baked in: idf is FLOORED (a term present in every candidate
+ * would otherwise get idf ≤ 0 and vanish, even when it's the whole point of the
+ * prompt). See IDF_FLOOR.
+ *
+ * Bilingual by design: memory titles + our MEMORY.md entries are Russian; prompts
+ * are mixed RU/EN. Tokenization is Unicode-letter/number aware so Cyrillic and
+ * Latin both tokenize, and the stopword set covers both languages.
+ */
+
+// BM25 knobs — standard defaults. Tunable; these get tuned live on analytics.
+const K1 = 1.2;
+const B = 0.75;
+// Tiny-corpus idf floor: with ≤30 docs, a term in most/all docs yields idf ≤ 0
+// under the classic `ln((N - df + 0.5)/(df + 0.5))`. Floor it so a ubiquitous but
+// on-topic term still contributes a little instead of scoring negative/zero.
+const IDF_FLOOR = 0.01;
+
+// Field weights: repeat a field's tokens N times in the candidate's bag so BM25's
+// term-frequency naturally up-weights title/tags/paths over the softer preview.
+const WEIGHT_TITLE = 3;
+const WEIGHT_TAGS = 2;
+const WEIGHT_PATHS = 2;
+const WEIGHT_PREVIEW = 1;
+
+// Bilingual stopwords (EN + RU) — high-frequency function words that carry no
+// topic signal. Kept deliberately small; over-stopping hurts recall more than a
+// few function words hurt precision on this tiny corpus.
+export const STOPWORDS = new Set([
+  // English
+  'the', 'a', 'an', 'and', 'or', 'but', 'if', 'is', 'are', 'was', 'were', 'be',
+  'to', 'of', 'in', 'on', 'at', 'for', 'with', 'by', 'as', 'it', 'this', 'that',
+  'these', 'those', 'i', 'you', 'we', 'they', 'he', 'she', 'my', 'our', 'your',
+  'do', 'does', 'did', 'not', 'no', 'so', 'up', 'out', 'can', 'will', 'would',
+  'how', 'what', 'when', 'where', 'why', 'which', 'who',
+  // Russian
+  'и', 'в', 'во', 'не', 'на', 'с', 'со', 'что', 'как', 'а', 'то', 'по', 'но',
+  'за', 'из', 'к', 'у', 'же', 'от', 'о', 'об', 'для', 'до', 'это', 'этот', 'эта',
+  'эти', 'мне', 'мы', 'вы', 'я', 'ты', 'он', 'она', 'они', 'бы', 'ли', 'да',
+  'или', 'если', 'так', 'при', 'над', 'под', 'без', 'есть',
+]);
+
+/**
+ * Tokenize a string into lowercased, Unicode-aware terms.
+ *  - split on any run of non-letter/non-number/non-underscore (so `foo/bar-baz`,
+ *    `модель.таблица` split into their segments — high-signal path/identifier bits
+ *    become their own terms);
+ *  - drop tokens shorter than 2 chars (noise);
+ *  - drop stopwords.
+ * Pure. Returns [] for non-strings.
+ * @param {string} s
+ * @returns {string[]}
+ */
+export function tokenize(s) {
+  if (typeof s !== 'string' || !s) return [];
+  const out = [];
+  // \p{L} letters (incl. Cyrillic), \p{N} numbers, plus `_`. Everything else splits.
+  for (const raw of s.toLowerCase().split(/[^\p{L}\p{N}_]+/u)) {
+    if (raw.length < 2) continue;
+    if (STOPWORDS.has(raw)) continue;
+    out.push(raw);
+  }
+  return out;
+}
+
+/**
+ * Build a candidate's weighted token bag from its matchable metadata fields
+ * (title ×3, tags ×2, repo_rel_paths ×2, preview ×1). NEVER touches `body` (the
+ * server already projected it to `preview`). Path segments are additionally split
+ * on `/._-` by the tokenizer so `models/staging/foo.sql` contributes `models`,
+ * `staging`, `foo`, `sql`.
+ * @param {object} cand  a primed light-index entry
+ * @returns {string[]} the weighted bag (with repetition)
+ */
+export function candidateBag(cand) {
+  if (!cand || typeof cand !== 'object') return [];
+  const bag = [];
+  const push = (text, weight) => {
+    const toks = tokenize(text);
+    for (let w = 0; w < weight; w++) bag.push(...toks);
+  };
+  push(cand.title, WEIGHT_TITLE);
+  if (Array.isArray(cand.tags)) push(cand.tags.join(' '), WEIGHT_TAGS);
+  if (Array.isArray(cand.repo_rel_paths)) push(cand.repo_rel_paths.join(' '), WEIGHT_PATHS);
+  push(cand.preview, WEIGHT_PREVIEW);
+  return bag;
+}
+
+/**
+ * Score a prompt against a pool of candidates with BM25-lite.
+ *
+ * @param {string} promptText  the user's current prompt (already truncated upstream)
+ * @param {Array<object>} candidates  primed light-index entries ({id,title,tags,repo_rel_paths,preview,…})
+ * @returns {Array<{id:string,score:number}>} candidates with score > 0, sorted desc by score.
+ *          Stable tie-break by id so ordering is deterministic across engines.
+ */
+export function scoreCandidates(promptText, candidates) {
+  const queryTerms = tokenize(promptText);
+  if (!Array.isArray(candidates) || candidates.length === 0 || queryTerms.length === 0) {
+    return [];
+  }
+
+  // Build per-candidate term-frequency maps + doc lengths from the weighted bags.
+  const docs = [];
+  for (const cand of candidates) {
+    if (!cand || cand.id == null) continue;
+    const bag = candidateBag(cand);
+    const tf = new Map();
+    for (const t of bag) tf.set(t, (tf.get(t) || 0) + 1);
+    docs.push({ id: cand.id, tf, length: bag.length });
+  }
+  if (docs.length === 0) return [];
+
+  const N = docs.length;
+  const avgdl = docs.reduce((s, d) => s + d.length, 0) / N || 1;
+
+  // Document frequency per UNIQUE query term (over the pool = the corpus).
+  const uniqueQueryTerms = [...new Set(queryTerms)];
+  const df = new Map();
+  for (const term of uniqueQueryTerms) {
+    let count = 0;
+    for (const d of docs) if (d.tf.has(term)) count++;
+    df.set(term, count);
+  }
+
+  // Robertson–Spärck-Jones idf with a tiny-corpus floor.
+  const idf = new Map();
+  for (const term of uniqueQueryTerms) {
+    const n = df.get(term) || 0;
+    const raw = Math.log((N - n + 0.5) / (n + 0.5) + 1); // +1 keeps it > 0 for df<N
+    idf.set(term, Math.max(raw, IDF_FLOOR));
+  }
+
+  const results = [];
+  for (const d of docs) {
+    let score = 0;
+    for (const term of uniqueQueryTerms) {
+      const f = d.tf.get(term);
+      if (!f) continue;
+      const num = f * (K1 + 1);
+      const den = f + K1 * (1 - B + B * (d.length / avgdl));
+      score += idf.get(term) * (num / den);
+    }
+    if (score > 0) results.push({ id: d.id, score });
+  }
+
+  results.sort((a, b) => (b.score - a.score) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  return results;
+}

package/client/memory-messages.js

@@ -0,0 +1,44 @@
+/**
+ * Team-memory user-facing strings — MINIMAL i18n seam for the CLIENT HOOK runtime
+ * (client/capture.js inject render), epic [0102] / T8 [0110] "report-wrong".
+ *
+ * WHY A SEPARATE COPY FROM server/lib/memory-messages.js:
+ * The client hook is a STANDALONE process installed to ~/.ai-lens/client/ (copied by
+ * cli/hooks.js installClientFiles, which ships every client/*.js). It cannot import
+ * server code — so it carries its own mirror of the ONE string it renders (the inject
+ * hint). Same keyed/locale shape as the server module so both translate identically.
+ * Keep the RU copy in sync with server/lib/memory-messages.js.
+ *
+ * SHAPE: `MESSAGES[locale][key]` — string or `(vars) => string`. `t(key, vars)`
+ * resolves the DEFAULT locale (RU) for now; `resolveLocale()` is the seam a future
+ * per-user locale plugs into (single default today, marked TODO).
+ */
+
+const DEFAULT_LOCALE = 'ru';
+
+const MESSAGES = {
+  ru: {
+    // The per-prompt inject hint appended after the memory_read pointer. `id` = the
+    // memory's id, so the agent can call the report tool with it verbatim.
+    inject_report_hint: ({ id }) =>
+      `неверно/устарело? → ai_lens_memory_report_wrong(id='${id}', comment='…')`,
+  },
+};
+
+/**
+ * Resolve the active locale. TODO(i18n): thread a per-user locale here later.
+ * Single default (RU) for now — mirrors server/lib/memory-messages.js.
+ */
+export function resolveLocale() {
+  return DEFAULT_LOCALE;
+}
+
+/** Keyed lookup for the active locale (falls back to default then the key). */
+export function t(key, vars = {}) {
+  const locale = resolveLocale();
+  const table = MESSAGES[locale] || MESSAGES[DEFAULT_LOCALE] || {};
+  const fallback = MESSAGES[DEFAULT_LOCALE] || {};
+  const val = table[key] ?? fallback[key];
+  if (val == null) return key;
+  return typeof val === 'function' ? val(vars) : val;
+}

package/client/sender.js

@@ -44,6 +44,7 @@ import {
   getClientMode,
   MESSAGES_PATH,
   MEMORY_INDEX_PATH,
+  MEMORY_OPT_OUT_PATH,
   DEFAULT_SERVER_URL,
   log,
 } from './config.js';
@@ -691,6 +692,10 @@ function buildHeaders(identity, authToken) {
   if (identity.email) headers['X-Developer-Git-Email'] = identity.email;
   if (identity.name)  headers['X-Developer-Name'] = encodeURIComponent(identity.name);
   if (authToken)      headers['X-Auth-Token'] = authToken;
+  // Per-person memory opt-out (T6d [0118]): presence of the flag file (toggled by
+  // `ai-lens memory off`) tells the server to stop PRIMING the team-memory cache.
+  // Best-effort: a stat error just omits the header (server keeps priming).
+  try { if (existsSync(MEMORY_OPT_OUT_PATH)) headers['X-Memory-Opt-Out'] = '1'; } catch { /* ignore */ }
   return headers;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-lens",
-  "version": "0.8.114",
+  "version": "0.8.117",
   "type": "module",
   "description": "Centralized session analytics for AI coding tools",
   "bin": {