hippo-memory 1.24.1 → 1.25.0

package/dist/cli.js

@@ -35,7 +35,7 @@ import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInsta
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, computeSchemaFit, Layer, } from './memory.js';
 import { resolveProjectIdentity } from './project-identity.js';
 import { detectSecret } from './secret-detect.js';
-import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, RECALL_DEFAULT_DENY_SCOPES, } from './store.js';
+import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, RECALL_DEFAULT_DENY_SCOPES, } from './store.js';
 import { markRetrieved, hybridSearch, physicsSearch, explainMatch, textOverlap } from './search.js';
 import { renderTraceContent, parseSteps } from './trace.js';
 import { deduplicateStore } from './dedupe.js';
@@ -722,15 +722,43 @@ async function cmdRecall(hippoRoot, query, flags) {
     // A5 stub auth: resolve the active tenant once and thread it through every
     // recall-time SELECT against `memories`. Cross-tenant rows must never surface.
     const tenantId = resolveTenantId({});
-    let localEntries = loadSearchEntries(hippoRoot, query, undefined, tenantId);
-    let globalEntries = isInitialized(globalRoot) ? loadSearchEntries(globalRoot, query, undefined, tenantId) : [];
+    // v1.25.0 (v39 follow-up #1): the direct CLI recall path applies the recall
+    // scope rule. SQL half via loadRecallSearchEntries in 'additive' mode —
+    // default-deny (`unknown:legacy` quarantine) always, and an explicit
+    // `--scope X` UNLOCKS envelope scope X on top of the default-admitted set
+    // (the CLI flag is historically a tag-boost hint over scope-NULL rows, so
+    // api.recall's narrowing exact-match would empty every tag-scoped recall —
+    // see passesCliRecallScopeFilter in recall-scope.ts). The regex-only
+    // `<source>:private:*` half is the JS post-filter below. Hoisted here
+    // (it previously lived with the boost flags): recallExplicitScope is the
+    // FILTER input; recallActiveScope (which falls back to detectScope()) stays
+    // boost-only — auto-detection must never become a filter input or
+    // detected-project recalls would change shape.
+    const recallExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    const requestedScopeForFilter = recallExplicitScope || undefined;
+    let localEntries = loadRecallSearchEntries(hippoRoot, query, undefined, tenantId, requestedScopeForFilter, 'additive');
+    let globalEntries = isInitialized(globalRoot) ? loadRecallSearchEntries(globalRoot, query, undefined, tenantId, requestedScopeForFilter, 'additive') : [];
     // v1.12.13 / C5 — WYSIATI counters. Track filter activity per the plan v3
     // Task 3 mapping table. dropped_pre_rank is the SUM of all non-budget
     // filter drops (pre-rank AND post-rank). Search-engine internal drops
     // (scored-to-zero rows that hybridSearch/physicsSearch returns fewer of)
     // are NOT counted in v1 — they are part of the rank step, not a filter.
+    // totalCandidates = post-SQL-predicate count (api.recall parity: measured
+    // after loadRecallSearchEntries, before the JS scope filter). NOTE the
+    // v1.12.13 accounting convention: SQL-excluded rows (quarantine + the
+    // v1.25.0 pre-window ':private:' exclusion) are pre-candidate and are NOT
+    // counted as drops; the JS half below normally drops 0 and exists as
+    // defense-in-depth (LIKE/regex divergence, exact-mode mismatch).
     const totalCandidatesCountCmd = localEntries.length + globalEntries.length;
     let droppedPreRankCountCmd = 0;
+    // v1.25.0: JS half of the recall scope rule (private-scope regex deny with
+    // explicit-request unlock), via the canonical helper — do not inline a
+    // fourth copy of this predicate.
+    const passesRecallScope = (e) => api.passesCliRecallScopeFilter(e.scope ?? null, requestedScopeForFilter);
+    const beforeScopeFilterCmd = localEntries.length + globalEntries.length;
+    localEntries = localEntries.filter(passesRecallScope);
+    globalEntries = globalEntries.filter(passesRecallScope);
+    droppedPreRankCountCmd += beforeScopeFilterCmd - (localEntries.length + globalEntries.length);
     // Bi-temporal filtering for physics path (hybridSearch handles it internally)
     if (asOf) {
         const filterAsOf = (entries) => {
@@ -782,7 +810,8 @@ async function cmdRecall(hippoRoot, query, flags) {
     const minResults = flags['min-results'] !== undefined
         ? parseInt(String(flags['min-results']), 10)
         : undefined;
-    const recallExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    // recallExplicitScope hoisted above the candidate loads (v1.25.0) — see the
+    // scope-filter block near the top of cmdRecall.
     const recallActiveScope = recallExplicitScope || detectScope();
     const useMultihop = flags['multihop'] === true || config.multihop.enabled;
     // L1 — graph-retrieval stream. `--graph-stream` forces rrf fusion + the graph stream
@@ -859,10 +888,16 @@ async function cmdRecall(hippoRoot, query, flags) {
         });
     }
     else if (hasGlobal) {
-        // Use searchBothHybrid for merged results with embedding support
+        // Use searchBothHybrid for merged results with embedding support.
+        // recallScope (v1.25.0): searchBothHybrid re-loads candidates internally,
+        // so the scope rule must be plumbed in — the filtered localEntries /
+        // globalEntries above are NOT what this path ranks.
         results = await searchBothHybrid(query, hippoRoot, globalRoot, {
             budget, mmr: mmrEnabled, mmrLambda, localBump, minResults, scope: recallActiveScope, tenantId,
             includeSuperseded, asOf,
+            recallScope: recallExplicitScope
+                ? { requested: recallExplicitScope, additive: true }
+                : {},
         });
     }
     else {
@@ -1695,8 +1730,30 @@ async function cmdExplain(hippoRoot, query, flags) {
     const globalRoot = getGlobalRoot();
     // A5: scope explain results to the active tenant.
     const tenantId = resolveTenantId({});
-    let explainLocalEntries = loadSearchEntries(hippoRoot, query, undefined, tenantId);
-    let explainGlobalEntries = isInitialized(globalRoot) ? loadSearchEntries(globalRoot, query, undefined, tenantId) : [];
+    // v1.25.0 (v39 follow-up #1): cmdExplain shares cmdRecall's leak class —
+    // same unscoped loads, same fix, same semantics (explain explains what
+    // recall would see). Flag hoisted above the loads; the note below keeps the
+    // command honest for an operator debugging a hidden row.
+    const explainExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    const explainRequestedScope = explainExplicitScope || undefined;
+    let explainLocalEntries = loadRecallSearchEntries(hippoRoot, query, undefined, tenantId, explainRequestedScope, 'additive');
+    let explainGlobalEntries = isInitialized(globalRoot) ? loadRecallSearchEntries(globalRoot, query, undefined, tenantId, explainRequestedScope, 'additive') : [];
+    const passesExplainScope = (e) => api.passesCliRecallScopeFilter(e.scope ?? null, explainRequestedScope);
+    explainLocalEntries = explainLocalEntries.filter(passesExplainScope);
+    explainGlobalEntries = explainGlobalEntries.filter(passesExplainScope);
+    // Honesty note (grill finding #2): the SQL predicate excludes denied rows
+    // BEFORE the candidate window (codex P2 fix), so the pipeline never sees
+    // them. For the diagnostic note only, probe the unscoped window and count
+    // what the scope policy hides — window-capped, so the count is a floor on
+    // large stores, which is fine for a "why is my row missing" hint.
+    const explainUnscopedProbe = [
+        ...loadSearchEntries(hippoRoot, query, undefined, tenantId),
+        ...(isInitialized(globalRoot) ? loadSearchEntries(globalRoot, query, undefined, tenantId) : []),
+    ];
+    const explainScopeDropped = explainUnscopedProbe.filter((e) => !passesExplainScope(e)).length;
+    if (explainScopeDropped > 0) {
+        console.error(`[note] ${explainScopeDropped} candidate${explainScopeDropped === 1 ? '' : 's'} hidden by recall scope policy (pass an explicit --scope to inspect).`);
+    }
     // Bi-temporal filtering
     if (explainAsOf) {
         const filterAsOfExplain = (entries) => {
@@ -1739,7 +1796,7 @@ async function cmdExplain(hippoRoot, query, flags) {
         : flags['local-bump'] !== undefined
             ? parseFloat(String(flags['local-bump']))
             : config.search.localBump;
-    const explainExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    // explainExplicitScope hoisted above the candidate loads (v1.25.0).
     const explainActiveScope = explainExplicitScope || detectScope();
     let results;
     let modeUsed;
@@ -1757,6 +1814,9 @@ async function cmdExplain(hippoRoot, query, flags) {
         results = await searchBothHybrid(query, hippoRoot, globalRoot, {
             budget, explain: true, mmr: mmrEnabled, mmrLambda, localBump, scope: explainActiveScope,
             includeSuperseded: explainIncludeSuperseded, asOf: explainAsOf, tenantId,
+            recallScope: explainExplicitScope
+                ? { requested: explainExplicitScope, additive: true }
+                : {},
         });
         modeUsed = 'searchBothHybrid';
     }
@@ -2429,6 +2489,10 @@ export function renderSleepResult(result) {
     if (result.shared !== undefined && result.shared > 0) {
         console.log(`\nAuto-shared ${result.shared} high-value memories to global store.`);
     }
+    if (result.secretSkipped !== undefined && result.secretSkipped > 0) {
+        // v1.25.0 (v39 follow-up #2): the secret veto is no longer silent.
+        console.log(`\nAuto-share: withheld ${result.secretSkipped} secret-flagged ${result.secretSkipped === 1 ? 'memory' : 'memories'} (secret veto).`);
+    }
     if (result.ambient) {
         console.log(`\n${renderAmbientSummary(result.ambient)}`);
     }