@gamaze/hicortex 0.16.1 → 0.16.2

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,8 +105,6 @@ EXTRACT into this markdown format:
 
 # Session Memory: ${date} - ${projectName}
 
-## Classification: [pick one: PUBLIC / WORK / PERSONAL / SENSITIVE]
-
 ### Decisions Made
 - [SUBJECT]: [decision] — [reasoning] (${date})
 
@@ -153,11 +151,6 @@ RULES:
   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.
-- 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
 - 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

@@ -81,17 +81,18 @@ export declare function formatIndexLine(r: MemorySearchResult & {
  */
 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[];
@@ -107,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.
@@ -127,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

package/dist/recall-index.js

@@ -58,7 +58,6 @@ exports.memoryTitle = memoryTitle;
 exports.formatIndexLine = formatIndexLine;
 exports.passesRelevanceGate = passesRelevanceGate;
 exports.parseStringListParam = parseStringListParam;
-exports.parsePrivacyParam = parsePrivacyParam;
 exports.handleRecallIndex = handleRecallIndex;
 exports.handleMemoryGet = handleMemoryGet;
 exports.formatMemoryGetText = formatMemoryGetText;
@@ -141,8 +140,8 @@ function passesRelevanceGate(r, minSimilarity) {
 }
 /** 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. */
 function parseStringListParam(v) {
     const items = Array.isArray(v)
         ? v.filter((x) => typeof x === "string")
@@ -152,13 +151,6 @@ function parseStringListParam(v) {
     const cleaned = items.map((s) => s.trim()).filter(Boolean);
     return cleaned.length > 0 ? cleaned : 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. */
-function parsePrivacyParam(v) {
-    return parseStringListParam(v);
-}
 /**
  * Handle a /recall-index request body. Thin Express adapter in mcp-server.ts;
  * all behavior lives here so tests exercise it directly.
@@ -185,13 +177,13 @@ async function handleRecallIndex(deps, body) {
     const minSimilarity = clampNumber(deps.options?.minSimilarity, DEFAULT_MIN_SIMILARITY, 0, 1);
     const turn = deps.registry.beginTurn(sessionId);
     // Optional client-side scoping (F1 + #203): project + mission_domains (soft
-    // affinity) and privacy (hard filter) ride the body and are pushed into
-    // retrieval. project is cwd-derived (CC/OC) or gateway-supplied; mission_domains
-    // is Hermes-declared (plugin config). Neither excludes anything — both are
-    // zero-boost-neutral score terms in computeScore.
+    // affinity) ride the body and are pushed into retrieval. project is cwd-
+    // derived (CC/OC) or gateway-supplied; mission_domains is Hermes-declared
+    // (plugin config). Neither excludes anything — both are zero-boost-neutral
+    // score terms in computeScore. (0.16.x: `privacy` is no longer threaded —
+    // vestigial column, never filtered; a plugin's privacy_filter is a no-op.)
     const filters = {
         project: typeof req.project === "string" && req.project ? req.project : undefined,
-        privacy: parsePrivacyParam(req.privacy),
         mission_domains: parseStringListParam(req.mission_domains),
     };
     let results;
@@ -238,10 +230,11 @@ async function handleRecallIndex(deps, body) {
  *
  *   - 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.
  */
 function handleMemoryGet(db, query) {
     const id = typeof query.id === "string" ? query.id : "";
@@ -257,9 +250,6 @@ function handleMemoryGet(db, query) {
     const mem = storage.getMemory(db, fullId);
     if (!mem)
         return notFound;
-    const privacy = parsePrivacyParam(query.privacy);
-    if (privacy && !privacy.includes(mem.privacy))
-        return notFound;
     storage.strengthenMemory(db, fullId, new Date().toISOString());
     // `citation` is server-rendered so every plugin surfaces the same built-in
     // provenance norm (owner directive 27.07) — see #193.

package/dist/retrieval.d.ts

@@ -178,10 +178,12 @@ export interface EmbedFn {
  *
  * #203 retrieval scoping: `project` and `missionDomains` are SOFT affinity
  * terms in computeScore (zero-boost neutral, never a penalty), NOT filters.
- * `privacy` remains a hard filter (security boundary). `sourceAgent` remains a
- * hard filter (kept for completeness; no production caller currently passes
- * it). When neither project nor missionDomains is sent, scoring is byte-
- * identical to pre-#203 — the kill-switch / no-op guarantee.
+ * `privacy` is NOT a filter (0.16.x: the column is fully vestigial — stored,
+ * never filtered; the distiller no longer sets it and retrieval ignores it
+ * entirely). `sourceAgent` remains a hard filter (kept for completeness; no
+ * production caller currently passes it). When neither project nor
+ * missionDomains is sent, scoring is byte-identical to pre-#203 — the
+ * kill-switch / no-op guarantee.
  */
 export declare function retrieve(db: Database.Database, embedFn: EmbedFn, query: string, options?: {
     limit?: number;
@@ -189,7 +191,6 @@ export declare function retrieve(db: Database.Database, embedFn: EmbedFn, query:
      *  Formerly a hard WHERE filter (#192); softening removes cross-scope
      *  starvation without excluding anything. */
     project?: string | null;
-    privacy?: string[];
     sourceAgent?: string;
     /** #203: Hermes mission domains (declared in plugin config). Soft domain
      *  affinity in computeScore via max overlapping memory_tags.weight. */
@@ -206,11 +207,10 @@ export declare function retrieve(db: Database.Database, embedFn: EmbedFn, query:
     queryEmbedding?: Float32Array;
 }): Promise<MemorySearchResult[]>;
 /**
- * Get recent context, optionally filtered by project and privacy.
+ * Get recent context, optionally filtered by project.
  */
 export declare function searchRecent(db: Database.Database, options?: {
     project?: string | null;
     limit?: number;
-    privacy?: string[];
 }): MemorySearchResult[];
 export {};

package/dist/retrieval.js

@@ -510,15 +510,16 @@ function reciprocalRankFusion(rankedLists, k = DEFAULT_RRF_K) {
  *
  * #203 retrieval scoping: `project` and `missionDomains` are SOFT affinity
  * terms in computeScore (zero-boost neutral, never a penalty), NOT filters.
- * `privacy` remains a hard filter (security boundary). `sourceAgent` remains a
- * hard filter (kept for completeness; no production caller currently passes
- * it). When neither project nor missionDomains is sent, scoring is byte-
- * identical to pre-#203 — the kill-switch / no-op guarantee.
+ * `privacy` is NOT a filter (0.16.x: the column is fully vestigial — stored,
+ * never filtered; the distiller no longer sets it and retrieval ignores it
+ * entirely). `sourceAgent` remains a hard filter (kept for completeness; no
+ * production caller currently passes it). When neither project nor
+ * missionDomains is sent, scoring is byte-identical to pre-#203 — the
+ * kill-switch / no-op guarantee.
  */
 async function retrieve(db, embedFn, query, options) {
     const limit = options?.limit ?? recallDefaults.searchLimit;
     const project = options?.project;
-    const privacy = options?.privacy;
     const sourceAgent = options?.sourceAgent;
     const missionDomains = options?.missionDomains;
     const now = new Date();
@@ -534,15 +535,17 @@ async function retrieve(db, embedFn, query, options) {
     // over-fetch — the old flat limit*3 intersected a global top-15 with (for the
     // median project) ~1% of the corpus, starving every filtered query.
     // #203: project is NO LONGER a filter (soft affinity now), so it does not
-    // trigger over-fetch; privacy/sourceAgent still do (they remain hard filters).
-    const filtered = Boolean(privacy || sourceAgent);
+    // trigger over-fetch; only sourceAgent still does (it remains a hard filter).
+    // 0.16.x: privacy is no longer a filter either (column is vestigial).
+    const filtered = Boolean(sourceAgent);
     const fetchLimit = filtered ? Math.min(limit * 20, 200) : limit * 3;
     let vecCandidates = storage.vectorSearch(db, queryEmbedding, fetchLimit, []);
     let ftsCandidates = [];
     try {
-        // privacy/sourceAgent are pushed into the FTS SQL (hard filters). project
-        // is NOT (it is a soft affinity boost in computeScore as of #203).
-        ftsCandidates = storage.searchFts(db, query, fetchLimit, privacy, sourceAgent);
+        // sourceAgent is pushed into the FTS SQL (hard filter). project is NOT (it
+        // is a soft affinity boost in computeScore as of #203). privacy is NOT
+        // (0.16.x: vestigial column, never filtered).
+        ftsCandidates = storage.searchFts(db, query, fetchLimit, sourceAgent);
     }
     catch {
         // FTS5 search can fail on special characters; fall back to vector-only
@@ -550,12 +553,9 @@ async function retrieve(db, embedFn, query, options) {
     if (vecCandidates.length === 0 && ftsCandidates.length === 0) {
         return [];
     }
-    // Post-filter vector candidates (sqlite-vec can't filter). privacy stays a
-    // hard filter (security boundary); project was removed here (#203 — it is now
-    // scored, not filtered). sourceAgent stays (see options doc).
-    if (privacy) {
-        vecCandidates = vecCandidates.filter((c) => privacy.includes(c.privacy));
-    }
+    // Post-filter vector candidates (sqlite-vec can't filter). sourceAgent stays
+    // a hard filter (see options doc); project is scored not filtered (#203);
+    // privacy is no longer filtered (0.16.x — vestigial).
     if (sourceAgent) {
         vecCandidates = vecCandidates.filter((c) => c.source_agent === sourceAgent);
     }
@@ -593,9 +593,8 @@ async function retrieve(db, embedFn, query, options) {
         if (!mem)
             continue;
         // #203: project check removed — project is a soft affinity in computeScore,
-        // not a filter. privacy (security) and sourceAgent stay as hard filters.
-        if (privacy && !privacy.includes(mem.privacy))
-            continue;
+        // not a filter. 0.16.x: privacy check removed — the column is vestigial,
+        // never filtered. sourceAgent stays a hard filter.
         if (sourceAgent && mem.source_agent !== sourceAgent)
             continue;
         candidateMap.set(gid, { mem, distance: DEFAULT_GRAPH_DISTANCE, source: "graph" });
@@ -677,12 +676,11 @@ async function retrieve(db, embedFn, query, options) {
     return results;
 }
 /**
- * Get recent context, optionally filtered by project and privacy.
+ * Get recent context, optionally filtered by project.
  */
 function searchRecent(db, options) {
     const limit = options?.limit ?? recallDefaults.recentLimit;
     const project = options?.project;
-    const privacy = options?.privacy;
     const now = new Date();
     // #192 breadth: 30 → 180-day default window (config recentWindowDays).
     // "Recent" for a long-lived corpus is a season, not a month; the narrow
@@ -691,9 +689,7 @@ function searchRecent(db, options) {
     if (project) {
         candidates = candidates.filter((c) => c.project === project);
     }
-    if (privacy) {
-        candidates = candidates.filter((c) => privacy.includes(c.privacy));
-    }
+    // 0.16.x: privacy filter removed — the column is vestigial, never filtered.
     if (candidates.length === 0)
         return [];
     const allIds = candidates.map((c) => c.id);

package/dist/schema-prototypes.d.ts

@@ -11,9 +11,8 @@
  *     embedding of the domain's config description instead.
  *   - weight(memory, tag) = cosine(memory embedding, prototype(tag)). Both
  *     vectors are L2-normalized, so cosine reduces to a dot product.
- *   - PRIMARY (memories.domain) = argmax-weight tag, overridden by any tagged
- *     domain flagged `compartment: true` (deliberate compartmentalization —
- *     the owner's Work firewall). Fully mechanical, no LLM.
+ *   - PRIMARY (memories.domain) = argmax-weight tag, with LLM tag order
+ *     breaking exact-weight ties. Fully mechanical, no LLM.
  *
  * The LLM decides ONLY the discrete part (which schemas apply — see
  * domain-classify.ts); ALL gradation is derived from embeddings here.
@@ -65,24 +64,20 @@ export interface WeightedTag {
     tag: string;
     weight: number | null;
 }
-/** The configured compartment domain names (DomainDef.compartment === true). */
-export declare function compartmentSet(domains: DomainDef[]): Set<string>;
 /**
  * Derive the PRIMARY tag (memories.domain) from a weighted tag set.
  *
  * Rules (deterministic, no LLM):
- *   1. Any tagged compartment domain wins — first one in array order if the
- *      (unusual) case of several arises.
- *   2. Else the argmax-weight tag. `tags` MUST be in LLM most-relevant-first
+ *   1. The argmax-weight tag. `tags` MUST be in LLM most-relevant-first
  *      order: ties (and all-null weights) resolve to the EARLIEST array
  *      position — strict `>` comparison keeps the first maximum.
- *   3. A null weight loses to any numeric weight (treated as -Infinity).
+ *   2. A null weight loses to any numeric weight (treated as -Infinity).
  *
  * Throws on an empty tag set — callers guarantee >= 1 tag (an empty tag set
  * from the classifier is a NO-FIT and must be routed through nofit.ts, never
  * here); an empty set reaching this function is a programming error.
  */
-export declare function derivePrimary(tags: WeightedTag[], compartments: Set<string>): string;
+export declare function derivePrimary(tags: WeightedTag[]): string;
 export interface PrototypeStat {
     domain: string;
     memberCount: number;
@@ -151,9 +146,9 @@ export declare function recomputeAllTagWeights(db: Database.Database, prototypes
 };
 /**
  * Re-derive the PRIMARY (memories.domain) of every tagged memory from its
- * current tag weights: compartment override first, else argmax weight, LLM
- * order (memory_tags insertion order = rowid, written most-relevant-first by
- * storage.setMemoryTags) breaking exact-weight ties.
+ * current tag weights: argmax weight, LLM order (memory_tags insertion order =
+ * rowid, written most-relevant-first by storage.setMemoryTags) breaking
+ * exact-weight ties.
  *
  * Memories with NO memory_tags rows are untouched (e.g. infra-skipped rows
  * awaiting classification — issue #150 discipline).

package/dist/schema-prototypes.js

@@ -12,9 +12,8 @@
  *     embedding of the domain's config description instead.
  *   - weight(memory, tag) = cosine(memory embedding, prototype(tag)). Both
  *     vectors are L2-normalized, so cosine reduces to a dot product.
- *   - PRIMARY (memories.domain) = argmax-weight tag, overridden by any tagged
- *     domain flagged `compartment: true` (deliberate compartmentalization —
- *     the owner's Work firewall). Fully mechanical, no LLM.
+ *   - PRIMARY (memories.domain) = argmax-weight tag, with LLM tag order
+ *     breaking exact-weight ties. Fully mechanical, no LLM.
  *
  * The LLM decides ONLY the discrete part (which schemas apply — see
  * domain-classify.ts); ALL gradation is derived from embeddings here.
@@ -30,7 +29,6 @@ exports.blobToVec = blobToVec;
 exports.l2Normalize = l2Normalize;
 exports.weightedAdd = weightedAdd;
 exports.tagWeight = tagWeight;
-exports.compartmentSet = compartmentSet;
 exports.derivePrimary = derivePrimary;
 exports.loadDomainPrototypes = loadDomainPrototypes;
 exports.computeDomainPrototypes = computeDomainPrototypes;
@@ -107,33 +105,23 @@ function tagWeight(memoryEmbedding, prototype) {
         dot += memoryEmbedding[i] * prototype[i];
     return dot;
 }
-/** The configured compartment domain names (DomainDef.compartment === true). */
-function compartmentSet(domains) {
-    return new Set(domains.filter((d) => d.compartment === true).map((d) => d.name));
-}
 /**
  * Derive the PRIMARY tag (memories.domain) from a weighted tag set.
  *
  * Rules (deterministic, no LLM):
- *   1. Any tagged compartment domain wins — first one in array order if the
- *      (unusual) case of several arises.
- *   2. Else the argmax-weight tag. `tags` MUST be in LLM most-relevant-first
+ *   1. The argmax-weight tag. `tags` MUST be in LLM most-relevant-first
  *      order: ties (and all-null weights) resolve to the EARLIEST array
  *      position — strict `>` comparison keeps the first maximum.
- *   3. A null weight loses to any numeric weight (treated as -Infinity).
+ *   2. A null weight loses to any numeric weight (treated as -Infinity).
  *
  * Throws on an empty tag set — callers guarantee >= 1 tag (an empty tag set
  * from the classifier is a NO-FIT and must be routed through nofit.ts, never
  * here); an empty set reaching this function is a programming error.
  */
-function derivePrimary(tags, compartments) {
+function derivePrimary(tags) {
     if (tags.length === 0) {
         throw new Error("derivePrimary: empty tag set (callers must pass >= 1 tag)");
     }
-    for (const t of tags) {
-        if (compartments.has(t.tag))
-            return t.tag;
-    }
     let best = tags[0];
     let bestWeight = best.weight ?? Number.NEGATIVE_INFINITY;
     for (let i = 1; i < tags.length; i++) {
@@ -313,15 +301,18 @@ function recomputeAllTagWeights(db, prototypes) {
 }
 /**
  * Re-derive the PRIMARY (memories.domain) of every tagged memory from its
- * current tag weights: compartment override first, else argmax weight, LLM
- * order (memory_tags insertion order = rowid, written most-relevant-first by
- * storage.setMemoryTags) breaking exact-weight ties.
+ * current tag weights: argmax weight, LLM order (memory_tags insertion order =
+ * rowid, written most-relevant-first by storage.setMemoryTags) breaking
+ * exact-weight ties.
  *
  * Memories with NO memory_tags rows are untouched (e.g. infra-skipped rows
  * awaiting classification — issue #150 discipline).
  */
 function refreshPrimaries(db, domains) {
-    const compartments = compartmentSet(domains);
+    // `domains` is accepted for API symmetry with the other reconsolidation
+    // passes (which need prototypes/weights); the primary is now pure argmax
+    // and does not depend on the domain set.
+    void domains;
     const rows = db
         .prepare(`SELECT mt.memory_id, mt.tag, mt.weight, m.domain
        FROM memory_tags mt JOIN memories m ON m.id = mt.memory_id
@@ -341,7 +332,7 @@ function refreshPrimaries(db, domains) {
     let updated = 0;
     const tx = db.transaction(() => {
         for (const [memoryId, entry] of byMemory) {
-            const primary = derivePrimary(entry.tags, compartments);
+            const primary = derivePrimary(entry.tags);
             if (primary !== entry.domain) {
                 update.run(primary, memoryId);
                 updated++;

package/dist/seed-lesson.js

@@ -65,7 +65,6 @@ async function injectSeedLesson(database, log = console.log) {
             project: "global",
             memoryType: "lesson",
             baseStrength: 0.95,
-            privacy: "WORK",
         });
         log("[hicortex] Seed lesson injected: Daily Self-Improvement Protocol");
     }

package/dist/storage.d.ts

@@ -54,11 +54,6 @@ export interface SetMemoryTagsOptions {
      * (repaired by the next nightly recompute).
      */
     weights?: Record<string, number | null>;
-    /**
-     * Compartment domain names (DomainDef.compartment === true): a tagged
-     * compartment domain becomes the primary regardless of weights.
-     */
-    compartments?: Set<string>;
 }
 /**
  * Set a memory's classification tags (graded schema model).
@@ -69,9 +64,8 @@ export interface SetMemoryTagsOptions {
  * row stores its association weight (NULL when not yet computed).
  *
  * The PRIMARY (memories.domain) is DERIVED here — never passed in by the LLM:
- * compartment override first, else argmax weight, else first tag (all-null
- * weights). The whole update is one transaction so domain, tag set, and
- * weights never diverge.
+ * argmax weight, else first tag (all-null weights). The whole update is one
+ * transaction so domain, tag set, and weights never diverge.
  *
  * @returns the derived primary written to memories.domain
  */
@@ -149,9 +143,10 @@ export declare function getBm25Weights(): Bm25Weights;
  *
  * `project` is NOT a filter here (#203): the hard project WHERE from #192 was
  * removed — project is now a soft affinity boost in retrieval.computeScore AND
- * a weighted field in BM25F (#205). `privacy` stays a hard filter (security
- * boundary, not a relevance signal). `sourceAgent` stays a hard filter (kept
- * for completeness; no production caller of retrieve() currently passes it).
+ * a weighted field in BM25F (#205). `privacy` is NOT a filter (0.16.x: the
+ * column is fully vestigial — stored, never filtered; the privacy IN-clause
+ * was removed). `sourceAgent` stays a hard filter (kept for completeness; no
+ * production caller of retrieve() currently passes it).
  *
  * #205 sign handling: FTS5's `bm25(table, w0, w1, …)` returns a NEGATIVE score
  * where MORE-negative = better match (it is 1 − the normalized BM25 score,
@@ -162,7 +157,7 @@ export declare function getBm25Weights(): Bm25Weights;
  * positionally as parameters (NOT string-interpolated) so query-planner
  * caching is unaffected and the config path is the only editor.
  */
-export declare function searchFts(db: Database.Database, query: string, limit?: number, privacy?: string[], sourceAgent?: string): Array<Memory & {
+export declare function searchFts(db: Database.Database, query: string, limit?: number, sourceAgent?: string): Array<Memory & {
     rank: number;
 }>;
 /**
@@ -184,6 +179,8 @@ export declare function insertMemoriesBatch(db: Database.Database, memories: Arr
     content: string;
     embedding: Float32Array;
     sourceAgent?: string;
+    sourceAgentId?: string | null;
+    sourceDomain?: string | null;
     sourceSession?: string | null;
     project?: string | null;
     privacy?: string;