@gamaze/hicortex 0.16.1 → 0.16.3

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 {
@@ -174,6 +187,27 @@ function captureLockWaitMs() {
     const env = Number(process.env.HICORTEX_CAPTURE_LOCK_WAIT_MS);
     return Number.isFinite(env) && env >= 0 ? env : CAPTURE_LOCK_WAIT_MS;
 }
+/**
+ * Read a positive finite number from a nightly config key, falling back to
+ * `def` when the key is absent/invalid. Used by the pre-flight retry knobs
+ * (#163): tuning knobs live in config, never hardcoded (cf. decayHalfLifeDays,
+ * recallMinSimilarity).
+ *
+ * A value that is PRESENT but rejected (non-number, non-finite, or ≤ 0) warns
+ * — e.g. an operator who sets `preflightAttempts: 0` intending "don't retry"
+ * would otherwise silently get the default 3. (Single-try is
+ * `preflightAttempts: 1`, so there's no functional gap — this just makes the
+ * silent coercion visible, consistent with the fail-explicit pattern.)
+ */
+function readPositiveConfig(config, key, def) {
+    const v = config[key];
+    if (v === undefined)
+        return def;
+    if (typeof v === "number" && Number.isFinite(v) && v > 0)
+        return v;
+    console.warn(`[hicortex] config "${key}" = ${String(v)} is not a positive finite number — using default ${def}.`);
+    return def;
+}
 const NIGHTLY_LOG_MAX_BYTES = 1024 * 1024; // 1 MB — years of normal runs
 /**
  * Keep ~/.hicortex/nightly.log bounded. The launchd plist and systemd unit
@@ -202,6 +236,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 +353,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
@@ -461,16 +510,72 @@ async function runClientNightly(config, dryRun, stateDir = HICORTEX_HOME, recapt
     const authToken = config.authToken;
     console.log(`[hicortex] Client nightly starting${dryRun ? " (dry run)" : ""}`);
     console.log(`[hicortex] Server: ${serverUrl}`);
-    // Verify server is reachable
-    try {
-        const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(5000) });
-        if (!resp.ok)
-            throw new Error(`HTTP ${resp.status}`);
-        const data = await resp.json();
-        console.log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+    // Verify server is reachable. Retry so a client waking from sleep (its
+    // network link not yet re-established) or a transient blip doesn't abort
+    // the whole run — the pre-flight only needs the link back, which can take
+    // ~1 min after wake.
+    //
+    // Config-overridable (#163): a wired Pi vs a sleeping laptop want different
+    // values. Defaults: 15s per-attempt timeout, 3 attempts, 60s gap.
+    //
+    // WALL-CLOCK NOTE: setTimeout and AbortSignal.timeout do NOT advance while
+    // macOS is asleep, so the ~2m45s worst case (3×15s + 2×60s) is wall-clock-
+    // optimistic — a sleeping laptop can straddle sleep cycles and the real
+    // elapsed time can exceed it. Not a defect: the capture lock isn't held
+    // during the retry and the cursor design is dup-over-loss, so a late success
+    // is harmless. Just don't treat 2m45s as a hard wall-clock bound.
+    const PREFLIGHT_TIMEOUT_MS = readPositiveConfig(config, "preflightTimeoutMs", 15_000);
+    const PREFLIGHT_ATTEMPTS = Math.max(1, Math.floor(readPositiveConfig(config, "preflightAttempts", 3)));
+    const PREFLIGHT_RETRY_GAP_MS = readPositiveConfig(config, "preflightRetryGapMs", 60_000);
+    let reachable = false;
+    for (let attempt = 1; attempt <= PREFLIGHT_ATTEMPTS; attempt++) {
+        try {
+            const resp = await fetch(`${serverUrl}/health`, { signal: AbortSignal.timeout(PREFLIGHT_TIMEOUT_MS) });
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}`);
+            const data = await resp.json();
+            console.log(`[hicortex] Server OK: v${data.version}, ${data.memories} memories`);
+            reachable = true;
+            break;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (attempt < PREFLIGHT_ATTEMPTS) {
+                console.error(`[hicortex] Server unreachable at ${serverUrl} (attempt ${attempt}/${PREFLIGHT_ATTEMPTS}): ${msg} — retrying in ${PREFLIGHT_RETRY_GAP_MS / 1000}s`);
+                await new Promise((r) => setTimeout(r, PREFLIGHT_RETRY_GAP_MS));
+            }
+            else {
+                console.error(`[hicortex] Server unreachable at ${serverUrl} after ${PREFLIGHT_ATTEMPTS} attempts: ${msg}`);
+            }
+        }
     }
-    catch (err) {
-        console.error(`[hicortex] Server unreachable at ${serverUrl}: ${err instanceof Error ? err.message : String(err)}`);
+    if (!reachable) {
+        // The abort was invisible for weeks once: a plain `return` let the oneshot
+        // exit 0, so systemd/launchd recorded success and the capture gap went
+        // unnoticed. Exit non-zero so `systemctl --user status` / launchd show the
+        // unit failed (safe — this is a timer-driven oneshot with no Restart=, so
+        // no loop), and fire the telemetry ping (ok=false) so the abort is
+        // distinguishable from "powered off / uninstalled" in the activity aggregate.
+        process.exitCode = 1;
+        if (!dryRun && (0, telemetry_js_1.isTelemetryEnabled)(config)) {
+            await (0, telemetry_js_1.sendTelemetry)({
+                id: (0, telemetry_js_1.getTelemetryId)(stateDir),
+                v: VERSION,
+                pv: telemetry_js_1.TELEMETRY_PAYLOAD_VERSION,
+                event: "nightly",
+                mode: "client",
+                // `agent` deliberately OMITTED: no transcripts have been read at
+                // pre-flight, so the type is genuinely unknown. The admin summary
+                // buckets a missing agent as "?" (distinct from cc/pi/oc/mixed) —
+                // sending "cc" here would miscount an aborting Hermes/OC-only client
+                // as a cc install. The success-path ping sends the real type once
+                // session sources are known.
+                mem: 0,
+                lessons: 0,
+                sessions: 0,
+                ok: false,
+            });
+        }
         console.error(`[hicortex] Aborting. Will retry next run.`);
         return; // Don't update last-run so we retry
     }
@@ -529,6 +634,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/pi-transcript-reader.d.ts

@@ -19,7 +19,7 @@
  *     --home-alice-projects-myagent--/
  *       2026-04-10T18-37-44-615Z_<uuid>.jsonl
  *       2026-04-11T07-51-28-282Z_<uuid>.jsonl
- *     --home-agents-Development-MAIC--/
+ *     --home-user-projects-ExampleApp--/
  *       ...
  *
  * The encoded-cwd uses double-dash separators: /home/alice/projects/myagent

package/dist/pi-transcript-reader.js

@@ -20,7 +20,7 @@
  *     --home-alice-projects-myagent--/
  *       2026-04-10T18-37-44-615Z_<uuid>.jsonl
  *       2026-04-11T07-51-28-282Z_<uuid>.jsonl
- *     --home-agents-Development-MAIC--/
+ *     --home-user-projects-ExampleApp--/
  *       ...
  *
  * The encoded-cwd uses double-dash separators: /home/alice/projects/myagent

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

@@ -75,23 +75,24 @@ export declare function formatIndexLine(r: MemorySearchResult & {
  * 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
+ * a relevance 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[];
@@ -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;
@@ -130,8 +129,8 @@ function formatIndexLine(r, maxLen = DEFAULT_TITLE_CHARS) {
  * 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
+ * a relevance 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.
  */
 function passesRelevanceGate(r, minSimilarity) {
@@ -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/redact.d.ts

@@ -5,8 +5,8 @@
  * Why this exists:
  *   - Session transcripts contain tool output: file reads, command output,
  *     env var dumps. These regularly contain API keys, tokens, and paths.
- *   - The distillation LLM is often remote (e.g., Ollama on MBP via
- *     Tailscale). Secrets in the transcript travel over the network.
+ *   - The distillation LLM is often remote (e.g., a mesh VPN link to a
+ *     GPU box). Secrets in the transcript travel over the network.
  *   - Even if the LLM correctly classifies the memory as SENSITIVE, the
  *     secret is already stored and searchable via hicortex_search.
  *   - Redaction runs BEFORE the LLM sees the text, eliminating the risk.

package/dist/redact.js

@@ -6,8 +6,8 @@
  * Why this exists:
  *   - Session transcripts contain tool output: file reads, command output,
  *     env var dumps. These regularly contain API keys, tokens, and paths.
- *   - The distillation LLM is often remote (e.g., Ollama on MBP via
- *     Tailscale). Secrets in the transcript travel over the network.
+ *   - The distillation LLM is often remote (e.g., a mesh VPN link to a
+ *     GPU box). Secrets in the transcript travel over the network.
  *   - Even if the LLM correctly classifies the memory as SENSITIVE, the
  *     secret is already stored and searchable via hicortex_search.
  *   - Redaction runs BEFORE the LLM sees the text, eliminating the risk.

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).