@gamaze/hicortex 0.16.0 → 0.16.2

package/dist/lessons-context.js

@@ -90,10 +90,11 @@ async function fetchLessonsBlock(cfg) {
     const project = (0, node_path_1.basename)(process.cwd()) || null;
     const selected = await (0, extensions_js_1.getLessonSelector)().select(data.lessons, { maxLessons, moduleIndex, project });
     const lessonLines = selected.map((l) => {
-        const titleMatch = l.content.match(/## Lesson: (.+)/);
         const typeMatch = l.content.match(/\*\*Type:\*\* (\w+)/);
         const severityMatch = l.content.match(/\*\*Severity:\*\* (\w+)/);
-        const title = titleMatch ? titleMatch[1] : l.content.slice(0, 150);
+        // First line, with any legacy `## Lesson:` prefix stripped — new lessons
+        // are stored topic-first without the prefix (memory_type carries the type).
+        const title = l.content.replace(/^##\s*Lesson:\s*/i, "").split("\n")[0].slice(0, 150);
         const meta = [severityMatch?.[1], typeMatch?.[1]].filter(Boolean).join(", ");
         return `- ${title}${meta ? ` (${meta})` : ""}`;
     });

package/dist/mcp-server.js

@@ -70,6 +70,7 @@ const recall_index_js_1 = require("./recall-index.js");
 const seed_lesson_js_1 = require("./seed-lesson.js");
 const distiller_js_1 = require("./distiller.js");
 const dedup_js_1 = require("./dedup.js");
+const init_js_1 = require("./init.js");
 // ---------------------------------------------------------------------------
 // Server state
 // ---------------------------------------------------------------------------
@@ -78,6 +79,21 @@ let llm = null;
 // llmConfig is module-level so the /distill handler can call resolveDistillFallback
 // without having to read config on every request. null when no LLM is configured.
 let llmConfig = null;
+// One-time-per-process deprecation warning for the `?privacy=` query param
+// (0.16.x: the column is vestigial, never filtered). Old clients/plugins still
+// send it; we accept it (backward compat) but warn ONCE so an operator relying
+// on privacy filtering discovers from the logs that it is now a no-op.
+let privacyDeprecationWarned = false;
+function warnDeprecatedPrivacyParamIfPresent(query, route) {
+    if (privacyDeprecationWarned)
+        return;
+    if (query.privacy === undefined || query.privacy === null || query.privacy === "")
+        return;
+    privacyDeprecationWarned = true;
+    console.warn(`[hicortex] client sent ?privacy= on /${route}, which is ignored since 0.16.2 — ` +
+        `privacy is no longer filtered server-side (the column is vestigial). ` +
+        `Use a separate Hicortex server for isolation. (This warning fires once per process.)`);
+}
 // distillFallbackMode controls whether a failed remote distill endpoint causes an
 // immediate abort ("strict", default) or a fallback to the base model ("local").
 let distillFallbackMode = "strict";
@@ -174,7 +190,6 @@ function createMcpServer() {
                 sourceAgent: "claude-code/manual",
                 project,
                 memoryType: memory_type ?? "episode",
-                privacy: "WORK",
             });
             return { content: [{ type: "text", text: `Memory stored (id: ${id.slice(0, 8)})` }] };
         }
@@ -360,6 +375,17 @@ async function startServer(options = {}) {
     // goes through resolveExplicitLlmConfig which requires a user-chosen provider.
     // If nothing is configured: start recall-only with an unmissable warning.
     const savedConfig = (0, llm_js_1.applyModelsBlock)(readConfigFile(stateDir));
+    // 0.16.2 activation gap: self-heal the agentId provenance field for
+    // pre-0.16.2 server installs on first boot after upgrade. The server's own
+    // nightly captures its sessions to localhost:8787/distill and needs this id;
+    // without it every self-captured memory landed with source_agent_id NULL.
+    // Hardened wrapper: throws on a malformed config instead of wiping, saves
+    // only when a new id was generated. Mutate savedConfig so any downstream
+    // read picks up the id even before the file is re-read.
+    if (savedConfig) {
+        const { agentId } = (0, init_js_1.ensureAndPersistAgentId)((0, node_path_1.join)(stateDir, "config.json"));
+        savedConfig.agentId = agentId;
+    }
     if (savedConfig?.llmBackend === "claude-cli") {
         const claudePath = (0, llm_js_1.findClaudeBinary)();
         if (claudePath) {
@@ -494,6 +520,7 @@ async function startServer(options = {}) {
         minSimilarity: savedConfig?.recallMinSimilarity,
         maxItems: savedConfig?.recallMaxItems,
         minPromptLength: savedConfig?.recallMinPromptChars,
+        titleChars: savedConfig?.recallTitleChars,
     };
     memoryInstructionsEnabled = savedConfig?.memoryInstructions !== false;
     if (resolvedAgents.dropped.length > 0) {
@@ -596,7 +623,7 @@ async function startServer(options = {}) {
             res.status(503).json({ error: "Server not initialized" });
             return;
         }
-        const { content, source_agent, project, memory_type, privacy, source_session, session_date } = req.body ?? {};
+        const { content, source_agent, source_agent_id, source_domain, project, memory_type, privacy, source_session, session_date } = req.body ?? {};
         if (!content || typeof content !== "string") {
             res.status(400).json({ error: "Missing or invalid 'content' field" });
             return;
@@ -618,10 +645,15 @@ async function startServer(options = {}) {
             const embedding = await (0, embedder_js_1.embed)(content);
             const id = storage.insertMemory(db, content, embedding, {
                 sourceAgent: source_agent ?? "remote-client",
+                // Attribution + provenance passthrough (0.16.x); null when absent.
+                sourceAgentId: typeof source_agent_id === "string" ? source_agent_id : null,
+                sourceDomain: typeof source_domain === "string" ? source_domain : null,
                 sourceSession: source_session ?? undefined,
                 project: project ?? undefined,
                 memoryType: memory_type ?? "episode",
-                privacy: privacy ?? "WORK",
+                // 0.16.x: privacy defaults to null (vestigial column). A legacy client
+                // that sends an explicit value is honored; absent → null.
+                privacy: typeof privacy === "string" ? privacy : null,
                 createdAt: session_date ? new Date(session_date).toISOString() : undefined,
             });
             res.status(201).json({ id, message: "Memory ingested" });
@@ -645,11 +677,12 @@ async function startServer(options = {}) {
         // No hardcoded default: absent limit → config-driven (searchLimit).
         const limit = req.query.limit ? Number(req.query.limit) : undefined;
         const project = typeof req.query.project === "string" && req.query.project ? req.query.project : undefined;
-        const privacy = typeof req.query.privacy === "string" && req.query.privacy
-            ? req.query.privacy.split(",").map((s) => s.trim()).filter(Boolean)
-            : undefined;
+        // 0.16.x: `privacy` query param is ACCEPTED for backward compat (old
+        // clients/plugins still send it) but no longer read — retrieval ignores
+        // privacy entirely (the column is vestigial, never filtered).
+        warnDeprecatedPrivacyParamIfPresent(req.query, "search");
         try {
-            const results = await retrieval.retrieve(db, embedder_js_1.embed, query, { limit, project, privacy });
+            const results = await retrieval.retrieve(db, embedder_js_1.embed, query, { limit, project });
             res.json({ results });
         }
         catch (err) {
@@ -691,9 +724,9 @@ async function startServer(options = {}) {
                     limit,
                     noStrengthen: true,
                     // #203: project + mission_domains are SOFT affinity (zero-boost
-                    // neutral), threaded into computeScore. privacy stays a hard filter.
+                    // neutral), threaded into computeScore. 0.16.x: privacy is no
+                    // longer threaded (vestigial column, never filtered).
                     project: filters?.project,
-                    privacy: filters?.privacy,
                     missionDomains: filters?.mission_domains,
                     queryEmbedding: queryVec,
                 });
@@ -702,17 +735,18 @@ async function startServer(options = {}) {
         }, req.body);
         res.status(r.status).json(r.body);
     });
-    // REST /memory?id=[&privacy=] — fetch one memory's full content (lazy-load
-    // counterpart of /recall-index for REST clients: Hermes/OC plugins). Marks
-    // it as used. Prefix ids resolve; a privacy filter miss reads as 404 (no
-    // existence leak). Logic in handleMemoryGet (recall-index.ts).
+    // REST /memory?id= — fetch one memory's full content (lazy-load counterpart
+    // of /recall-index for REST clients: Hermes/OC plugins). Marks it as used.
+    // Prefix ids resolve. 0.16.x: the `privacy` query param is accepted but
+    // ignored (column is vestigial, never filtered). Logic in handleMemoryGet.
     app.get("/memory", (req, res) => {
         if (!db) {
             res.status(503).json({ error: "Server not initialized" });
             return;
         }
+        warnDeprecatedPrivacyParamIfPresent(req.query, "memory");
         try {
-            const r = (0, recall_index_js_1.handleMemoryGet)(db, { id: req.query.id, privacy: req.query.privacy });
+            const r = (0, recall_index_js_1.handleMemoryGet)(db, { id: req.query.id });
             res.status(r.status).json(r.body);
         }
         catch (err) {
@@ -727,12 +761,11 @@ async function startServer(options = {}) {
         }
         const project = typeof req.query.project === "string" && req.query.project ? req.query.project : undefined;
         // No hardcoded default: absent limit → config-driven (recentLimit).
+        // 0.16.x: `privacy` query param accepted but ignored (vestigial column).
         const limit = req.query.limit ? Number(req.query.limit) : undefined;
-        const privacy = typeof req.query.privacy === "string" && req.query.privacy
-            ? req.query.privacy.split(",").map((s) => s.trim()).filter(Boolean)
-            : undefined;
+        warnDeprecatedPrivacyParamIfPresent(req.query, "recent");
         try {
-            const results = retrieval.searchRecent(db, { project, limit, privacy });
+            const results = retrieval.searchRecent(db, { project, limit });
             res.json({ results });
         }
         catch (err) {
@@ -806,7 +839,7 @@ async function startServer(options = {}) {
             res.status(503).json({ error: "No LLM configured — run npx @gamaze/hicortex init. Session will be retried." });
             return;
         }
-        const { text, messages, source_agent, project, session_id, segment_id, session_date, privacy } = req.body ?? {};
+        const { text, messages, source_agent, source_agent_id, source_domain, project, session_id, segment_id, session_date, privacy } = req.body ?? {};
         // Resolve the conversation text from either the pre-denoised string or raw messages array.
         let conversationText;
         if (typeof text === "string" && text.length > 0) {
@@ -897,12 +930,18 @@ async function startServer(options = {}) {
                 for (const { entry, embedding, i } of toStore) {
                     out.push(storage.insertMemory(db, entry, embedding, {
                         sourceAgent: source_agent ?? "unknown",
+                        // Attribution + provenance only (0.16.x): client-declared, never
+                        // filtered. Default null for older clients that don't send them.
+                        sourceAgentId: typeof source_agent_id === "string" ? source_agent_id : null,
+                        sourceDomain: typeof source_domain === "string" ? source_domain : null,
                         // Per-chunk key: "<session_id>[#<segment_id>]#<i>". The prefix
                         // matches the dedup checks above, so a re-run is idempotent.
                         sourceSession: sourcePrefix ? `${sourcePrefix}#${i}` : undefined,
                         project: project ?? undefined,
                         memoryType: "episode",
-                        privacy: privacy ?? "WORK",
+                        // 0.16.x: privacy defaults to null (vestigial column). A legacy
+                        // client that sends an explicit value is honored; absent → null.
+                        privacy: typeof privacy === "string" ? privacy : null,
                         createdAt,
                     }));
                 }
@@ -1249,17 +1288,25 @@ async function startServer(options = {}) {
 const resolveMemoryId = storage.resolveMemoryId;
 /**
  * Read ~/.hicortex/config.json (persisted by init with LLM and license config).
+ * Routes through loadConfigStrict: a malformed existing file (bad JSON /
+ * non-object / unreadable) emits a visible WARN then fails-soft to null; an
+ * absent file (ENOENT) silently returns null. Without this routing the
+ * agentId self-heal's throw would be unreachable from boot (the old swallow
+ * → null → `if (savedConfig)` guard skipped it).
  */
 function readConfigFile(stateDir) {
+    const configPath = (0, node_path_1.join)(stateDir, "config.json");
+    let loaded;
     try {
-        const { readFileSync } = require("node:fs");
-        const { join } = require("node:path");
-        const configPath = join(stateDir, "config.json");
-        return JSON.parse(readFileSync(configPath, "utf-8"));
+        loaded = (0, init_js_1.loadConfigStrict)(configPath);
     }
-    catch {
+    catch (e) {
+        console.warn(`[hicortex] ${configPath} exists but could not be parsed — server booting degraded ` +
+            `(config-driven LLM/decay/recall knobs and agentId self-heal will not apply). ` +
+            `Fix the JSON and restart. Cause: ${e instanceof Error ? e.message : String(e)}`);
         return null;
     }
+    return loaded.hadFile ? loaded.config : null;
 }
 /**
  * Self-heal: if the daemon plist/systemd unit has a pinned version

package/dist/nightly.js

@@ -71,15 +71,28 @@ const state_js_1 = require("./state.js");
 const capture_cursors_js_1 = require("./capture-cursors.js");
 const capture_js_1 = require("./capture.js");
 const telemetry_js_1 = require("./telemetry.js");
+const init_js_1 = require("./init.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 function readNightlyConfig(stateDir) {
+    const configPath = (0, node_path_1.join)(stateDir, "config.json");
+    let loaded;
     try {
-        const configPath = (0, node_path_1.join)(stateDir, "config.json");
-        return JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        loaded = (0, init_js_1.loadConfigStrict)(configPath);
     }
-    catch {
+    catch (e) {
+        // Malformed existing config (bad JSON / non-object / unreadable): visible
+        // WARN so the operator fixes it, then fail-soft to null. The strict load
+        // also protects the agentId self-heal below — its throw is now reachable
+        // here (without this routing, a swallowed parse → null → the `if
+        // (savedConfig)` guard would skip the self-heal entirely).
+        console.warn(`[hicortex] ${configPath} exists but could not be parsed — running degraded ` +
+            `(agentId self-heal and config-driven knobs will not apply this run). ` +
+            `Fix the JSON and re-run. Cause: ${e instanceof Error ? e.message : String(e)}`);
         return null;
     }
+    // ENOENT → hadFile=false → null (install not set up yet; silent, matches the
+    // old catch→null behavior).
+    return loaded.hadFile ? loaded.config : null;
 }
 function readConfigLicenseKey(stateDir) {
     try {
@@ -202,6 +215,17 @@ async function runNightly(options = {}) {
     (0, state_js_1.migrateLegacyState)(stateDir);
     // Check mode: client or server
     const savedConfig = readNightlyConfig(stateDir);
+    // 0.16.2 activation gap: pre-0.16.2 installs never re-run init, so their
+    // config has no agentId → capture sent source_agent_id: null forever (the
+    // provenance feature was inert for the whole existing fleet). Self-heal on
+    // the first nightly after upgrade: ensureAndPersistAgentId generates + writes
+    // the id once (idempotent thereafter). Mutate the in-memory savedConfig so
+    // BOTH capture paths (server line below, client via runClientNightly's param)
+    // read the value without re-reading the file.
+    if (savedConfig) {
+        const { agentId } = (0, init_js_1.ensureAndPersistAgentId)((0, node_path_1.join)(stateDir, "config.json"));
+        savedConfig.agentId = agentId;
+    }
     if (savedConfig?.mode === "client") {
         // --capture-only is accepted in client mode but irrelevant: client nightly
         // is already capture-only (no consolidation step).
@@ -308,10 +332,14 @@ async function runNightly(options = {}) {
                 }
                 // Step 2: pack each session's delta into ≤60K segments and POST to the
                 // local daemon via /distill; cursors advance on confirmed success.
+                // source_agent_id / source_domain are per-client provenance from
+                // config.json (agentId / sourceDomain) — attribution only, no filtering.
                 const result = await (0, capture_js_1.captureBatches)(batches, {
                     post: makeLocalPost(port),
                     cursorStore,
                     dryRun,
+                    sourceAgentId: savedConfig?.agentId,
+                    sourceDomain: savedConfig?.sourceDomain,
                 });
                 memoriesIngested = result.memoriesIngested;
                 // A 429/401 stop must hold the watermark too (fix 1): the loop abandoned
@@ -529,6 +557,10 @@ async function runClientNightly(config, dryRun, stateDir = HICORTEX_HOME, recapt
                 post: makeRemotePost(serverUrl, authToken),
                 cursorStore,
                 dryRun,
+                // Per-client provenance from config.json (agentId / sourceDomain). The
+                // server stores these alongside source_agent; nothing filters on them.
+                sourceAgentId: config.agentId,
+                sourceDomain: config.sourceDomain,
             });
             memoriesIngested = result.memoriesIngested;
             sessionsSent = result.sessionsSent;

package/dist/nofit.d.ts

@@ -90,7 +90,7 @@ export declare function resolveNoFit(db: Database.Database, memoryId: string, do
  * primary derives naturally inside setMemoryTags). Logged distinctly so
  * weak primaries are auditable apart from LLM-tagged rows.
  */
-export declare function applyWeakPrimary(db: Database.Database, memoryId: string, domain: string, weight: number, compartments: Set<string>): void;
+export declare function applyWeakPrimary(db: Database.Database, memoryId: string, domain: string, weight: number): void;
 /**
  * Apply no-association decay to a no-fit-below-floor memory:
  *   - clear any leftover memory_tags rows (e.g. a legacy "Unsorted" tag from

package/dist/nofit.js

@@ -137,10 +137,9 @@ function resolveNoFit(db, memoryId, domains, prototypes, floor) {
  * primary derives naturally inside setMemoryTags). Logged distinctly so
  * weak primaries are auditable apart from LLM-tagged rows.
  */
-function applyWeakPrimary(db, memoryId, domain, weight, compartments) {
+function applyWeakPrimary(db, memoryId, domain, weight) {
     storage.setMemoryTags(db, memoryId, [domain], {
         weights: { [domain]: weight },
-        compartments,
     });
     console.log(`[hicortex] weak-primary ${domain} w=${weight.toFixed(2)} for ${memoryId}`);
 }

package/dist/prompts.js

@@ -105,28 +105,40 @@ EXTRACT into this markdown format:
 
 # Session Memory: ${date} - ${projectName}
 
-## Classification: [pick one: PUBLIC / WORK / PERSONAL / SENSITIVE]
-
 ### Decisions Made
-- [decision]: [reasoning] (${date})
+- [SUBJECT]: [decision] — [reasoning] (${date})
 
 ### Facts Learned
-- [fact]: [context/source] (${date})
+- [SUBJECT]: [fact] — [context/source] (${date})
 
 ### Problems & Solutions
-- [problem] → [solution that worked] (${date})
+- [SUBJECT]: [problem] → [solution that worked] (${date})
 
 ### Project State Changes
-- [what changed]: [from → to] (${date})
+- [SUBJECT]: [what changed], [from → to] (${date})
 
 ### Key Entities & Relationships
 - [entity A] → [relationship] → [entity B] (${date})
 
 ### Corrections & Rejections
-- [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
+- [SUBJECT]: [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
   (Include: tool use denials, "no/wrong/redo", style feedback, approach rejections,
    user corrections of AI assumptions, quality complaints like "too verbose")
 
+TOPIC-FIRST RULE (critical — read carefully):
+Every item MUST begin with its [SUBJECT]: the concrete thing it is about — the
+system, file, component, decision area, or entity. The subject is what a future
+reader would search for.
+- Write:  "Electrical load calculation: don't bundle unknown loads into one figure — user rejected the estimate"
+- NOT:    "User rejected AI's bundling of unknown loads"
+- Write:  "Nightly capture (Hermes): cron sessions are excluded — source='cron' is skipped before distillation"
+- NOT:    "Discovered that cron sessions are filtered out"
+Reason: each item's first words become the memory's one-line index entry AND
+dominate its search embedding. An item that opens with a category label, a
+sentiment ("Strong Negative"), or "User rejected…" is unfindable — it matches
+every emotionally-similar prompt and no topically-relevant one. Front-load the
+subject; put reaction, intensity and reasoning AFTER it.
+
 RULES:
 - Extract MAX 20 items total (quality over quantity)
 - Each must be useful if recalled in a future session
@@ -136,12 +148,9 @@ RULES:
 - PRIORITIZE Corrections & Rejections — these are high-value signals for learning
   what the user does NOT want. Even a single "no" or style correction is worth extracting.
 - Strong language or profanity from the user is a high-intensity signal — it indicates
-  the correction matters deeply. Note the intensity in the extraction.
-- PRIVACY CLASSIFICATION (one of):
-  - PUBLIC: general tech knowledge, open-source patterns, publicly available info
-  - WORK: project-specific decisions, architecture choices, client/business context
-  - PERSONAL: personal preferences, family, health, lifestyle, private life
-  - SENSITIVE: API keys mentioned, credentials, financial account details, medical records
+  the correction matters deeply. Note the intensity AFTER the subject, never before it
+  (e.g. "Pricing tiers: strongly rejected per-agent billing — …", not
+  "[Strong Negative] User rejected per-agent billing"). The subject always comes first.
 - Omit any section that has zero items (don't include empty sections)
 - If nothing worth extracting, output ONLY: "NO_EXTRACT"
 `;

package/dist/recall-index.d.ts

@@ -25,13 +25,31 @@ import { SessionRecallRegistry } from "./recall-registry.js";
 export interface RecallIndexOptions {
     /** Minimum measured cosine for vector-only candidates (config
      *  `recallMinSimilarity`). FTS-matched candidates pass regardless — a BM25
-     *  text match is direct evidence of relevance. Default 0.55 (the neutral
-     *  placeholder similarity is 0.5; anything at/below that is noise). */
+     *  text match is direct evidence of relevance. Default 0.62 (raised from 0.55
+     *  on 2026-08-03 per a 0.01-step floor sweep on the rewritten corpus): steady
+     *  ~3:1 noise:signal removal with no knee; 0.62 = +2.2pts precision, 10/98
+     *  prompts silent, sits below the 0.63 local pessimum. The floor is a noise
+     *  dial, NOT a silence mechanism — at 0.62 each correctly-silenced empty prompt
+     *  comes with ~1.5 wrongly-silenced (real signal); a non-cosine gate is the
+     *  real silence fix (eval #3 §4). */
     minSimilarity?: number;
-    /** Max index lines per response (config `recallMaxItems`). Default 6. */
+    /** Max index lines per response (config `recallMaxItems`). Default 5
+     *  (lowered from 6 on 2026-08-03). Per-slot decomposition at floor 0.62:
+     *  slot 6 gives NO prompt its first relevant memory — "6 is wrong" is the
+     *  robust, prompt-set-independent finding, and 5 captures it. The K-sweep
+     *  is monotone (precision@4 33.7% > @6 30.6% > @8 28.3%), so 4 is
+     *  lower-noise — but the 4-vs-5 distinction rests on 5 of 98 prompts and is
+     *  overfitting-fragile (K and the floor were tuned on the same set); 5 hedges
+     *  with coverage at modest cost. Lower to 4 if a fresh-prompt eval replicates. */
     maxItems?: number;
     /** Prompts shorter than this are skipped (continuations, "yes", "do it"). */
     minPromptLength?: number;
+    /** Max chars of the memory's first line shown in an index entry (config
+     *  `recallTitleChars`). Default 100 (reverted from 150 on 2026-08-03): the
+     *  full-corpus relevance eval (#3, §5) found 100 vs 150 statistically
+     *  identical (0.6pts apart, N=40, full CI overlap); 100 saves ~13% tokens
+     *  per block. */
+    titleChars?: number;
 }
 export interface RecallIndexResult {
     status: number;
@@ -39,20 +57,42 @@ export interface RecallIndexResult {
 }
 /** First content line, de-markdowned and truncated — the index line title. */
 export declare function memoryTitle(content: string, maxLen?: number): string;
-/** Relevance gate: real text match, or measured cosine above the floor. */
+/**
+ * Render one production index line. Exported (2026-08-02, relevance eval #v2)
+ * so the eval can measure the REAL rendered surface instead of reimplementing
+ * it — `maxLen` threads through to `memoryTitle` unchanged (default
+ * DEFAULT_TITLE_CHARS = 100, config `recallTitleChars`) so the eval's snippet-length
+ * sweep (spec §4.2) can call this SAME function at 100/150/title1sent without
+ * duplicating the date/scope/agent/type meta-line logic.
+ */
+export declare function formatIndexLine(r: MemorySearchResult & {
+    domain?: string | null;
+}, maxLen?: number): string;
+/**
+ * Relevance gate: a real BM25 text match (FTS) passes unconditionally; a
+ * vector-only candidate must clear `minSimilarity`.
+ *
+ * NOTE: FTS hits BYPASS the similarity floor, so raising the floor shifts
+ * weight toward FTS-sourced entries. In practice FTS is currently inert on
+ * real prompts — eval #3 had 0 FTS rows / 2,208 (2,203 vector + 5 graph), and
+ * a 12-prompt live bedrock sample returned 96/96 vector — so the floor change
+ * is safe as measured. But FTS quality is unmeasured; if FTS starts firing
+ * (e.g. as #205's fielded-BM25 retune beds in), give it its own eval.
+ */
 export declare function passesRelevanceGate(r: MemorySearchResult, minSimilarity: number): boolean;
 /** Recall filters a client may push per request (#193 review F1): a scoped
- *  plugin (Hermes privacy_filter / default_project) must be able to narrow
+ *  plugin (Hermes default_project / mission_domains) must be able to narrow
  *  recall exactly like the legacy /search prefetch did — dropping them
  *  silently would leak out-of-scope memory titles into the injected index.
  *
- *  #203: `project` and `mission_domains` are now SOFT affinity signals in
- *  retrieval (zero-boost neutral, never a filter / penalty); `privacy` stays a
- *  hard filter (security boundary). They ride the body → retrieveFn →
- *  retrieve() → computeScore path unchanged in shape. */
+ *  #203: `project` and `mission_domains` are SOFT affinity signals in
+ *  retrieval (zero-boost neutral, never a filter / penalty). 0.16.x: `privacy`
+ *  is gone from this shape entirely — the column is vestigial, never filtered,
+ *  so a plugin's `privacy_filter` is a harmless no-op the server no longer
+ *  threads through. The body field is still ACCEPTED (backward compat) but
+ *  ignored. */
 export interface RecallFilters {
     project?: string;
-    privacy?: string[];
     /** #203: Hermes mission domains (declared in plugin config). Soft domain
      *  affinity in computeScore via max overlapping memory_tags.weight. */
     mission_domains?: string[];
@@ -68,14 +108,9 @@ export interface RecallIndexDeps {
 }
 /** Normalize a request-supplied string-list param: array of strings or a CSV
  *  string → string[] | undefined. Anything else (or an empty result) means
- *  "absent" — never a partial guess. Shared by `parsePrivacyParam` and
- *  `mission_domains` (#203) so both accept `["A","B"]` and `"A, B"` alike. */
+ *  "absent" — never a partial guess. Used by `mission_domains` (#203) so it
+ *  accepts `["A","B"]` and `"A, B"` alike. */
 export declare function parseStringListParam(v: unknown): string[] | undefined;
-/** Normalize a request-supplied privacy filter: array of strings or a CSV
- *  string → string[] | undefined. Anything else (or an empty result) means
- *  "no filter" — never a partial guess. Delegates to parseStringListParam;
- *  kept as a named export for tests and handleMemoryGet callers. */
-export declare function parsePrivacyParam(v: unknown): string[] | undefined;
 /**
  * Handle a /recall-index request body. Thin Express adapter in mcp-server.ts;
  * all behavior lives here so tests exercise it directly.
@@ -88,14 +123,14 @@ export declare function handleRecallIndex(deps: RecallIndexDeps, body: unknown):
  *
  *   - Short/prefix ids resolve via storage.resolveMemoryId (F6) — the 8-char
  *     citation ids agents are taught must work here like on /update, /delete.
- *   - Optional `privacy` filter (array or CSV): when present and the memory's
- *     privacy level is not in the allowed set, respond 404 with the SAME
- *     not-found message — a scoped client must not learn the memory exists.
  *   - A successful fetch is real use: access_count + 1 (strengthen).
+ *
+ * 0.16.x: the `privacy` filter gate was removed — the column is vestigial and
+ * never filtered. Callers may still send a `privacy` field (backward compat)
+ * but it is ignored.
  */
 export declare function handleMemoryGet(db: Database.Database, query: {
     id?: unknown;
-    privacy?: unknown;
 }): RecallIndexResult;
 /**
  * MCP `hicortex_get` presentation: handleMemoryGet's result framed as the