@gamaze/hicortex 0.16.1 → 0.16.3

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;

package/dist/storage.js

@@ -69,10 +69,10 @@ function insertMemory(db, content, embedding, opts = {}) {
     const result = db
         .prepare(`INSERT OR IGNORE INTO memories
        (id, content, base_strength, last_accessed, access_count,
-        created_at, ingested_at, source_agent, source_session, project,
-        privacy, memory_type)
-       VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", sourceSession, opts.project ?? null, opts.privacy ?? "WORK", opts.memoryType ?? "episode");
+        created_at, ingested_at, source_agent, source_agent_id, source_session,
+        source_domain, project, privacy, memory_type)
+       VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", opts.sourceAgentId ?? null, sourceSession, opts.sourceDomain ?? null, opts.project ?? null, opts.privacy ?? null, opts.memoryType ?? "episode");
     if (result.changes > 0) {
         // New row — store its vector.
         db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(id, embedToBlob(embedding));
@@ -192,9 +192,8 @@ function deleteMemory(db, memoryId) {
  * 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
  */
@@ -209,7 +208,7 @@ function setMemoryTags(db, memoryId, tags, options = {}) {
         tag,
         weight: options.weights?.[tag] ?? null,
     }));
-    const primary = (0, schema_prototypes_js_1.derivePrimary)(weighted, options.compartments ?? new Set());
+    const primary = (0, schema_prototypes_js_1.derivePrimary)(weighted);
     const setDomain = db.prepare("UPDATE memories SET domain = ? WHERE id = ?");
     const clearTags = db.prepare("DELETE FROM memory_tags WHERE memory_id = ?");
     const insertTag = db.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag, weight) VALUES (?, ?, ?)");
@@ -352,9 +351,10 @@ function getBm25Weights() {
  *
  * `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,
@@ -365,14 +365,9 @@ function getBm25Weights() {
  * positionally as parameters (NOT string-interpolated) so query-planner
  * caching is unaffected and the config path is the only editor.
  */
-function searchFts(db, query, limit = 10, privacy, sourceAgent) {
+function searchFts(db, query, limit = 10, sourceAgent) {
     const conditions = ["memories_fts MATCH ?"];
     const params = [query];
-    if (privacy && privacy.length > 0) {
-        const placeholders = privacy.map(() => "?").join(", ");
-        conditions.push(`m.privacy IN (${placeholders})`);
-        params.push(...privacy);
-    }
     if (sourceAgent) {
         conditions.push("m.source_agent = ?");
         params.push(sourceAgent);
@@ -460,18 +455,21 @@ function deleteLinks(db, memoryId) {
  * Batch insert memories. Returns count inserted.
  */
 function insertMemoriesBatch(db, memories) {
+    // privacy default is null (0.16.x: the distiller no longer sets WORK — the
+    // column is vestigial, never filtered, and goes NULL unless a caller sends
+    // an explicit value).
     const insertMem = db.prepare(`INSERT INTO memories
      (id, content, base_strength, last_accessed, access_count,
-      created_at, ingested_at, source_agent, source_session, project,
-      privacy, memory_type)
-     VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?)`);
+      created_at, ingested_at, source_agent, source_agent_id, source_session,
+      source_domain, project, privacy, memory_type)
+     VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
     const insertVec = db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)");
     const tx = db.transaction(() => {
         let count = 0;
         for (const mem of memories) {
             const id = (0, node_crypto_1.randomUUID)();
             const ts = nowIso();
-            insertMem.run(id, mem.content, mem.baseStrength ?? 0.5, ts, ts, ts, mem.sourceAgent ?? "default", mem.sourceSession ?? null, mem.project ?? null, mem.privacy ?? "WORK", mem.memoryType ?? "episode");
+            insertMem.run(id, mem.content, mem.baseStrength ?? 0.5, ts, ts, ts, mem.sourceAgent ?? "default", mem.sourceAgentId ?? null, mem.sourceSession ?? null, mem.sourceDomain ?? null, mem.project ?? null, mem.privacy ?? null, mem.memoryType ?? "episode");
             insertVec.run(id, embedToBlob(mem.embedding));
             count++;
         }

package/dist/telemetry.d.ts

@@ -6,7 +6,11 @@
  *   v        — package version
  *   pv       — payload schema version
  *   mode     — server or client
- *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   agent    — cc, pi, oc, or mixed (detected from session sources); OMITTED
+ *              when the agent type is genuinely unknown (pre-flight abort — no
+ *              transcripts read yet). The admin summary buckets a missing agent
+ *              as "?", distinct from any real type, so an aborting Hermes/OC
+ *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
  *   sessions — sessions distilled this run
@@ -41,7 +45,14 @@ export interface TelemetryPayload {
     id: string;
     v: string;
     mode: string;
-    agent: string;
+    /**
+     * Agent type detected from session sources (cc/pi/oc/mixed). OMITTED when
+     * unknown — currently only the pre-flight abort path, where no transcripts
+     * have been read yet (sending "cc" there mislabelled aborting Hermes/OC
+     * clients in the admin aggregate). The admin summary buckets a missing agent
+     * as "?", which is the honest signal.
+     */
+    agent?: string;
     mem: number;
     lessons: number;
     sessions: number;

package/dist/telemetry.js

@@ -7,7 +7,11 @@
  *   v        — package version
  *   pv       — payload schema version
  *   mode     — server or client
- *   agent    — cc, pi, oc, or mixed (detected from session sources)
+ *   agent    — cc, pi, oc, or mixed (detected from session sources); OMITTED
+ *              when the agent type is genuinely unknown (pre-flight abort — no
+ *              transcripts read yet). The admin summary buckets a missing agent
+ *              as "?", distinct from any real type, so an aborting Hermes/OC
+ *              client is never miscounted as "cc".
  *   mem      — total memory count
  *   lessons  — total lesson count
  *   sessions — sessions distilled this run

package/dist/types.d.ts

@@ -13,9 +13,23 @@ export interface Memory {
     ingested_at: string;
     source_agent: string;
     source_session: string | null;
+    /**
+     * Stable attribution id of the capturing client (a per-install UUID from
+     * config.json `agentId`). Survives agent/machine renames — unlike
+     * `source_agent` (a readable name). Attribution only; nothing filters on it.
+     * NULL on memories captured before this column existed. (0.16.x)
+     */
+    source_agent_id: string | null;
     project: string | null;
     domain: string | null;
-    privacy: "PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE";
+    /**
+     * Provenance only (0.16.x): the client-declared topic/domain of the
+     * capturing agent (config.json `sourceDomain`). NOT used for recall filtering
+     * or scoring, and NOT the content-classified primary (that is `domain`
+     * above). NULL when the client declares none. Echoed back on /memory GET.
+     */
+    source_domain: string | null;
+    privacy: ("PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE") | null;
     memory_type: "episode" | "lesson" | "fact" | "decision";
     updated_at: string | null;
 }
@@ -40,7 +54,7 @@ export interface MemorySearchResult {
     access_count: number;
     memory_type: string;
     project: string | null;
-    /** Origin agent (e.g. "hermes/atlas", "cc/mbp5") — surfaced in the recall
+    /** Origin agent (e.g. "hermes/profile-name", "cc/machine-name") — surfaced in the recall
      *  one-liner so agents can calibrate trust (#202 provenance). Optional on the
      *  result type (matches how `domain` is threaded) to avoid breaking fixtures. */
     source_agent?: string | null;
@@ -157,6 +171,15 @@ export interface HicortexConfig {
     serverUrl?: string;
     /** Bearer token for the Hicortex server. Localhost bypasses auth by default. */
     authToken?: string;
+    /**
+     * Stable per-install UUID generated by `init` (see ensureAgentId in init.ts;
+     * never rotated). Attribution identity of the capturing client — stored on
+     * each captured memory as `source_agent_id` (see Memory.source_agent_id) and
+     * sent on every /distill segment. Survives agent/machine renames, unlike the
+     * readable `source_agent` name. Pure attribution; nothing filters or scopes
+     * on it. (0.16.x)
+     */
+    agentId?: string;
     /** @deprecated Use the Hicortex server for distillation and consolidation. */
     llmBaseUrl?: string;
     /** @deprecated Use the Hicortex server for distillation and consolidation. */
@@ -194,6 +217,21 @@ export interface HicortexConfig {
     consolidateHour?: number;
     /** @deprecated The OC plugin no longer opens its own database. */
     dbPath?: string;
+    /**
+     * Client-declared topic/domain of THIS capturing agent (provenance only,
+     * 0.16.x). Sent on captured memories as `source_domain` (see
+     * Memory.source_domain) — NOT used for recall filtering or scoring, and NOT
+     * the content-classified primary (which is the server-derived `domain`
+     * column on each memory, classified against `domains` below).
+     *
+     * DISTINCT from `domains` (plural) directly below: `domains` is the
+     * config-owned VOCABULARY — the server's life-sphere list that memories are
+     * content-classified against; this singular `sourceDomain` is the client
+     * declaring "I am an agent that works on topic X", recorded as provenance on
+     * what it captures. Do not conflate the two. (Renamed from `domain` in
+     * 0.16.x — one char from `domains`, meant something unrelated.)
+     */
+    sourceDomain?: string;
     /**
      * Optional config-owned domain list — the user's top-level memory spheres
      * (life areas OR project/topic areas). When present, the nightly multi-tag
@@ -205,7 +243,7 @@ export interface HicortexConfig {
      * Server-mode `init` scaffolds a generic 5-domain default (Work, Personal,
      * People, Health, Finance — see GENERIC_DEFAULT_DOMAINS in init.ts) when
      * this key is absent, and NEVER touches an existing list. A power-user
-     * example (compartment flag, custom weakPrimaryFloor) ships as
+     * example (custom weakPrimaryFloor) ships as
      * domains.example.json in the package root.
      *
      * NO fallback bucket is needed or special-cased (owner amendment 07.07):
@@ -222,18 +260,33 @@ export interface HicortexConfig {
      * near its lower tail). See domains.example.json for a worked example.
      */
     weakPrimaryFloor?: number;
+    /**
+     * Per-attempt timeout (ms) for the CLIENT nightly's pre-flight GET /health
+     * check before capturing (#163). Default 15000. Overridable per machine —
+     * a wired Pi vs a sleeping laptop want different values. See runClientNightly
+     * in nightly.ts. No effect in server mode (server capture is localhost).
+     */
+    preflightTimeoutMs?: number;
+    /**
+     * Max attempts for the client nightly's pre-flight /health retry loop (#163).
+     * Default 3. Attempts are spaced preflightRetryGapMs apart; on exhaustion the
+     * run aborts with a non-zero exit code and an ok=false telemetry ping so the
+     * failure is visible to systemd/launchd and the activity aggregate.
+     */
+    preflightAttempts?: number;
+    /**
+     * Gap (ms) between pre-flight /health attempts in the client nightly (#163).
+     * Default 60000. Wall-clock-optimistic on a sleeping laptop — setTimeout does
+     * NOT advance while macOS is asleep, so real elapsed time can exceed the
+     * nominal worst case. Not a defect (capture lock isn't held; cursor design is
+     * dup-over-loss); just don't treat the nominal sum as a hard bound.
+     */
+    preflightRetryGapMs?: number;
 }
 /** A config-owned life-sphere domain (see HicortexConfig.domains). */
 export interface DomainDef {
     name: string;
     description: string;
-    /**
-     * Deliberate compartmentalization (graded-schema spec, 07.07.2026): when
-     * true, this domain becomes the PRIMARY (memories.domain) whenever it is
-     * tagged, overriding the argmax-weight rule. The owner's config flags only
-     * Work — a work/life firewall. Optional; absent = false.
-     */
-    compartment?: boolean;
 }
 /** Response from license validation API. */
 export interface LicenseInfo {
@@ -286,8 +339,14 @@ export interface ModuleIndex {
 export interface InsertMemoryOptions {
     sourceAgent?: string;
     sourceSession?: string | null;
+    /** Stable client UUID (config.json `agentId`). Attribution only. */
+    sourceAgentId?: string | null;
+    /** Client-declared topic/domain of the capturing agent. Provenance only. */
+    sourceDomain?: string | null;
     project?: string | null;
-    privacy?: string;
+    /** 0.16.x: vestigial — stored but never filtered. null (or absent) when the
+     *  caller doesn't declare one; an explicit value is honored as-is. */
+    privacy?: string | null;
     memoryType?: string;
     baseStrength?: number;
     createdAt?: string;
@@ -297,16 +356,3 @@ export interface VectorSearchOptions {
     limit?: number;
     excludeIds?: string[];
 }
-/** Options for FTS search. */
-export interface FtsSearchOptions {
-    limit?: number;
-    privacy?: string[];
-    sourceAgent?: string;
-}
-/** Options for retrieval. */
-export interface RetrievalOptions {
-    limit?: number;
-    project?: string | null;
-    privacy?: string[];
-    sourceAgent?: string;
-}

package/domains.example.json

@@ -33,14 +33,13 @@
   "_powerUserExample": {
     "_readme": [
       "A narrower life-sphere set for users who want tighter buckets.",
-      "`compartment: true` makes a domain the PRIMARY whenever it is tagged — a deliberate work/life firewall.",
+      "The PRIMARY domain is derived by argmax association weight (LLM tag order breaks ties) — no manual override flag.",
       "`weakPrimaryFloor` (default 0.45) is the minimum embedding similarity for a no-fit memory to earn a weak primary; tune it from your corpus."
     ],
     "domains": [
       {
         "name": "Work",
-        "description": "Employer, day job, client projects, workstreams",
-        "compartment": true
+        "description": "Employer, day job, client projects, workstreams"
       },
       {
         "name": "Personal",

package/hermes-plugin/hicortex/README.md

@@ -22,7 +22,7 @@ That's the whole surface. No `sync_turn`, no compaction/session-end capture —
 
 ### Pushed recall index (0.7.0, server ≥ 0.14)
 
-Instead of injecting full memory content every turn, `prefetch` sends the user's message to the server's `POST /recall-index` and injects the returned **index block** verbatim — one line per memory (id, title, date), capped and relevance-gated server-side. The agent fetches full content with `hicortex_get(id)` only when a line is actually relevant; that fetch is what strengthens the memory (exposure ≠ use). All tuning knobs (`recallMaxItems`, `recallMinSimilarity`, `recallReshowTurns`, `recallMinPromptChars`, …) live in the **server** config — the plugin carries none. Dedup is turn-based and server-side per session; the plugin resets it at `initialize` (the Hermes `MemoryProvider` interface exposes no compaction signal, so a mid-session context rebuild cannot trigger a reset — the server's turn-based re-show window covers that gap). Against a pre-0.14 server (404) the plugin falls back to the 0.6.x `GET /search` full-content prefetch, fail-soft, re-probing the endpoint every 10 minutes so a later server upgrade is picked up without a gateway restart. The recall calls carry the profile's configured `privacy_filter`/`default_project` and use a short dedicated timeout (1.5 s) so a slow server can never stall a turn.
+Instead of injecting full memory content every turn, `prefetch` sends the user's message to the server's `POST /recall-index` and injects the returned **index block** verbatim — one line per memory (id, title, date), capped and relevance-gated server-side. The agent fetches full content with `hicortex_get(id)` only when a line is actually relevant; that fetch is what strengthens the memory (exposure ≠ use). All tuning knobs (`recallMaxItems`, `recallMinSimilarity`, `recallReshowTurns`, `recallMinPromptChars`, …) live in the **server** config — the plugin carries none. Dedup is turn-based and server-side per session; the plugin resets it at `initialize` (the Hermes `MemoryProvider` interface exposes no compaction signal, so a mid-session context rebuild cannot trigger a reset — the server's turn-based re-show window covers that gap). Against a pre-0.14 server (404) the plugin falls back to the 0.6.x `GET /search` full-content prefetch, fail-soft, re-probing the endpoint every 10 minutes so a later server upgrade is picked up without a gateway restart. The recall calls carry the profile's configured `default_project` (and `mission_domains`) and use a short dedicated timeout (1.5 s) so a slow server can never stall a turn. (`privacy_filter` is deprecated since 0.7.2 — the server ignores privacy; see [Configuration](#configuration).)
 
 ### Per-agent standing context (0.13)
 
@@ -84,6 +84,8 @@ export HICORTEX_AUTH_TOKEN=hctx-default-token   # or your custom token
 
 Env overrides: `HICORTEX_URL`, `HICORTEX_AUTH_TOKEN`.
 
+> **`privacy_filter` is DEPRECATED** (plugin 0.7.2 / server 0.16.2). The server no longer filters on privacy — the `privacy` column is vestigial (stored, never filtered). The setting is still accepted for backward compatibility but is now a harmless no-op; setting it emits a one-time-per-process warning in the gateway log. For work/personal isolation, run a **separate Hicortex server** per scope rather than relying on in-server privacy filtering.
+
 ## Topology
 
 - **Server host:** runs Hicortex. Set `hicortex_url: http://localhost:8787` (localhost bypasses auth).

package/hermes-plugin/hicortex/config.py

@@ -8,9 +8,15 @@ plugin also works with env-only setup.
 from __future__ import annotations
 
 import json
+import logging
 import os
 from typing import Any, Dict, Optional
 
+logger = logging.getLogger(__name__)
+
+# One-time-per-process guard for the privacy_filter deprecation warning.
+_privacy_filter_deprecation_warned = False
+
 # Declarative config schema — drives `hermes memory setup` (see MemoryProvider
 # .get_config_schema). Field shape per the Hermes MemoryProvider contract:
 # key, label, description, default, required, secret, env_var, choices, url.
@@ -21,7 +27,7 @@ CONFIG_SCHEMA: list[dict[str, Any]] = [
         "description": (
             "URL of the Hicortex memory server. On the server host use "
             "http://localhost:8787; on other machines use the server's "
-            "Tailscale hostname, e.g. http://memory-server:8787."
+            "private hostname, e.g. http://memory-server:8787."
         ),
         "default": "http://localhost:8787",
         "required": True,
@@ -56,8 +62,15 @@ CONFIG_SCHEMA: list[dict[str, Any]] = [
     },
     {
         "key": "privacy_filter",
-        "label": "Privacy filter",
-        "description": "Comma-separated privacy levels to include (e.g. WORK,PERSONAL).",
+        "label": "Privacy filter (DEPRECATED)",
+        "description": (
+            "DEPRECATED since plugin 0.7.2 / server 0.16.2. The server no "
+            "longer filters on privacy — the column is vestigial. This setting "
+            "is now a harmless no-op: it is still accepted for backward "
+            "compat but ignored. For work/personal isolation, run a separate "
+            "Hicortex server per scope. (Historically: comma-separated privacy "
+            "levels to include, e.g. WORK,PERSONAL.)"
+        ),
         "default": "WORK,PERSONAL",
         "required": False,
     },
@@ -94,14 +107,19 @@ def _config_path(hermes_home: Optional[str] = None) -> str:
 
 def load_config() -> Dict[str, Any]:
     """Load merged config: file <- env overrides <- defaults."""
+    global _privacy_filter_deprecation_warned
     path = _config_path()
     cfg: Dict[str, Any] = {}
+    file_set_privacy_filter = False
     if os.path.exists(path):
         try:
             with open(path, encoding="utf-8") as f:
                 cfg = json.load(f) or {}
         except Exception:
             cfg = {}
+        # Detect an EXPLICIT user setting (the default is applied via setdefault
+        # below); only warn when the profile actually configured it.
+        file_set_privacy_filter = "privacy_filter" in cfg
 
     # Env overrides
     if os.environ.get("HICORTEX_URL"):
@@ -113,6 +131,19 @@ def load_config() -> Dict[str, Any]:
     cfg.setdefault("hicortex_url", "http://localhost:8787")
     cfg.setdefault("recall_limit", 5)
     cfg.setdefault("privacy_filter", "WORK,PERSONAL")
+
+    # 0.16.2 deprecation: privacy_filter is a no-op now (server ignores privacy
+    # entirely). Warn once per process if the profile explicitly sets it.
+    if file_set_privacy_filter and not _privacy_filter_deprecation_warned:
+        _privacy_filter_deprecation_warned = True
+        logger.warning(
+            "hicortex: config.json sets 'privacy_filter', which is deprecated "
+            "since plugin 0.7.2 / server 0.16.2 — the server no longer filters "
+            "on privacy (the column is vestigial). It is a harmless no-op now. "
+            "For work/personal isolation, run a separate Hicortex server per "
+            "scope. (This warning fires once per process.)"
+        )
+
     return cfg
 
 

package/hermes-plugin/hicortex/plugin.yaml

@@ -1,5 +1,5 @@
 name: hicortex
-version: 0.7.0
+version: 0.7.2
 description: "Self-learning memory for Hermes agents — every session is distilled into lessons overnight, and your agent wakes up wiser. Pushes a compact per-turn recall index (lazy-loaded with hicortex_get), injects fresh lessons plus a per-agent standing context block, and exposes the full 9-tool memory surface (search, get, recent, ingest, lessons, index, graph, update, delete) via a shared Hicortex server. Stdlib-only."
 pip_dependencies: []
 hooks: []

package/hermes-plugin/hicortex/provider.py

@@ -210,7 +210,8 @@ class HicortexProvider(MemoryProvider):
             self._recall_limit = 5
         self._privacy = cfg.get("privacy_filter", "WORK,PERSONAL")
         # #203 scope: declared knowledge domains for this role-bound agent
-        # (e.g. Lenny → Health). Soft affinity boost on recall; never excludes.
+        # (e.g. a health-focused agent → Health). Soft affinity boost on
+        # recall; never excludes.
         _md_raw = cfg.get("mission_domains") or ""
         self._mission_domains = [d.strip() for d in _md_raw.split(",") if d.strip()]
         self._agent_name = _resolve_agent_name(cfg)
@@ -446,6 +447,11 @@ class HicortexProvider(MemoryProvider):
             lines.append("Lessons:")
             for l in lessons:
                 c = (l.get("content") or "").strip().replace("\n", " ")
+                # Legacy lessons were stored with a "## Lesson:" prefix; new ones are
+                # topic-first (selected by memory_type, not the prefix). Strip it so
+                # Hermes renders the same topic-first line as the CC/OC lessons blocks.
+                if c.startswith("## Lesson: "):
+                    c = c[len("## Lesson: "):]
                 lines.append(f"- {c[:200]}")
         if idx.get("total"):
             lines.append(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Self-learning memory for AI agents — experience captured automatically, distilled into lessons overnight, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, and Pi.",
   "main": "dist/index.js",
   "bin": {