hippo-memory 1.13.1 → 1.13.3

package/dist/cli.js

@@ -58,6 +58,30 @@ import { buildCorrectionLatency } from './correction-latency.js';
 import * as api from './api.js';
 import * as predictionsModule from './predictions.js';
 import { computePlanningFallacyHint } from './predictions.js';
+import { createHash } from 'node:crypto';
+import { detectAnchoring, hashQueryText, buildSessionKey, getOrCreateRing, appendRecall, snapshotRing, } from './recall-history.js';
+// v0.33 / J1 — Module-level per-(tenant, session) recall-history ring map.
+// Each CLI process maintains its OWN Map; no IPC / no cross-process sharing
+// (plan v3 decision: per-pipeline rings, see docs/plans/2026-05-26-j1-anchoring-detector.md).
+//
+// IMPORTANT single-shot CLI limitation (codex round-2 catch): in normal
+// terminal usage each `hippo recall` invocation spawns a fresh Node
+// process, so this Map is recreated empty every time and J1 cannot
+// accumulate history across invocations. CLI J1 only fires in
+// long-running processes (the cmdSleep / consolidate loops, batch
+// scripts that call cmdRecall in-process, or tests). MCP and HTTP
+// pipelines DO accumulate because their host processes are long-lived
+// (hippo serve, MCP server). For CLI users who want per-session
+// anchoring in single-shot mode, the recommendation is to run via
+// `hippo serve` and call HTTP /v1/memories?session_id=... (the HTTP
+// ring persists across calls within the server process). A J1-v1.1
+// follow-up may add SQLite-backed CLI persistence (migration v30
+// recall_history table per the original brainstorm option D).
+const sessionRecallHistoryCli = new Map();
+/** Test-only: reset the module-level recall-history Map. Call from beforeEach. */
+export function __resetSessionRecallHistoryCli() {
+    sessionRecallHistoryCli.clear();
+}
 import * as client from './client.js';
 import { detectServer, removePidfileIfOwned } from './server-detect.js';
 import { resolveTenantId } from './tenant.js';
@@ -1022,18 +1046,66 @@ async function cmdRecall(hippoRoot, query, flags) {
         droppedByBudgetCountCmd = results.length - limit;
         results = results.slice(0, limit);
     }
+    // v0.33 / J1 — CLI per-pipeline anchoring detector. Each pipeline (api.recall,
+    // cmdRecall, MCP) computes its own AnchoringHint via the shared detectAnchoring
+    // helper against its own top-1 + its own per-(tenant, session) ring buffer.
+    // HIPPO_ANCHORING=off short-circuits BEFORE both the ring lookup and the
+    // detect call so disabled tenants pay truly zero work. When sessionId is
+    // absent we emit recall_anchor_skipped_no_session for J1-v2 telemetry.
+    let cmdAnchoringHint = null;
+    if (process.env.HIPPO_ANCHORING !== 'off') {
+        if (sessionId) {
+            const ringKey = buildSessionKey(tenantId, sessionId);
+            const ring = getOrCreateRing(sessionRecallHistoryCli, ringKey);
+            const queryHash = hashQueryText(query);
+            const topId = results[0]?.entry.id ?? null;
+            cmdAnchoringHint = detectAnchoring(snapshotRing(ring), queryHash, topId);
+            // Append AFTER detect (snapshot was taken before). anchoredOn carries
+            // the memoryId of any hint that fired, feeding the cooldown logic for
+            // the NEXT cmdRecall on this session.
+            appendRecall(ring, queryHash, topId, cmdAnchoringHint?.memoryId);
+        }
+        else {
+            // Telemetry: caller had no sessionId so ring tracking is skipped.
+            // Per the recall-audit convention at api.ts:854, use SHA-256/16
+            // for prompt hashing (NOT hashQueryText which is FNV-1a 32-bit
+            // for recall matching; brute-force trivial for low-entropy
+            // queries). Codex round-1 P1 / round-2 P2 catch.
+            emitCliAudit(hippoRoot, 'recall_anchor_skipped_no_session', undefined, {
+                query_hash: createHash('sha256').update(query).digest('hex').slice(0, 16),
+                query_length: query.length,
+            });
+        }
+    }
     // v1.12.13 / C5 — Build suppressionSummary for cmdRecall pipeline. Surfaced
     // in --why text output and in the --json JSON output. cmdRecall does not
     // run the summarizeOverflow path (api.recall does) and does not currently
     // expose fresh-tail in the CLI, so those two counters are 0 here.
+    // v0.33 / J1: suppressedByInterference is bumped by 1 when cmdAnchoringHint
+    // fires with reason='memory_dominance' (the only reason that counts as
+    // interference; query_repeat is a re-ask, not memory competition).
+    const cmdSuppressedByInterference = cmdAnchoringHint?.reason === 'memory_dominance' ? 1 : 0;
     const cmdSuppressionSummary = api.buildSuppressionSummary({
         totalCandidates: totalCandidatesCountCmd,
         droppedPreRank: droppedPreRankCountCmd,
         droppedByBudget: droppedByBudgetCountCmd,
         summarySubstitutionsAdded: 0,
         freshTailAdded: 0,
-        suppressedByInterference: 0,
+        suppressedByInterference: cmdSuppressedByInterference,
     });
+    // v0.33 / J1 — emit pipeline-local audit op when a hint fires (lockstep
+    // with api.recall's audit pattern; each pipeline emits for its own hits).
+    if (cmdAnchoringHint?.reason === 'memory_dominance') {
+        emitCliAudit(hippoRoot, 'recall_anchor_detected_memory_dominance', cmdAnchoringHint.memoryId, {
+            memory_id: cmdAnchoringHint.memoryId,
+            query_count: cmdAnchoringHint.queryCount ?? null,
+        });
+    }
+    else if (cmdAnchoringHint?.reason === 'query_repeat') {
+        emitCliAudit(hippoRoot, 'recall_anchor_detected_query_repeat', cmdAnchoringHint.memoryId, {
+            memory_id: cmdAnchoringHint.memoryId,
+        });
+    }
     // v0.32 / J3.2 — auto-injection of reference-class baserate when the
     // CLI query carries a forward-prediction phrase AND a class matches.
     // cmdRecall runs its own pipeline (doesn't go through api.recall for
@@ -1135,6 +1207,7 @@ async function cmdRecall(hippoRoot, query, flags) {
                 // matches. A forward-claim query that finds no memories STILL
                 // produces useful planning-fallacy debias when the class resolves.
                 ...(cmdPlanningFallacyHint ? { planningFallacyHint: cmdPlanningFallacyHint } : {}),
+                ...(cmdAnchoringHint ? { anchoringHint: cmdAnchoringHint } : {}),
             };
             if (includeContinuity) {
                 out.continuity = {
@@ -1147,6 +1220,11 @@ async function cmdRecall(hippoRoot, query, flags) {
             console.log(JSON.stringify(out));
             return;
         }
+        // v0.33 / J1 — render anchoring hint above planning hint (anchoring
+        // is the stronger cognitive-pull warning so it gets first position).
+        if (cmdAnchoringHint) {
+            console.log(`[anchored_on: ${cmdAnchoringHint.memoryId}] ${cmdAnchoringHint.summary}`);
+        }
         // v0.32 / J3.2 — render hint BEFORE the no-memories message so the
         // calling agent sees its track record even when the query missed
         // every memory. Same single-line shape + JSON.stringify-safe phrase
@@ -1221,6 +1299,7 @@ async function cmdRecall(hippoRoot, query, flags) {
             total: output.length,
             suppressionSummary: cmdSuppressionSummary,
             ...(cmdPlanningFallacyHint ? { planningFallacyHint: cmdPlanningFallacyHint } : {}),
+            ...(cmdAnchoringHint ? { anchoringHint: cmdAnchoringHint } : {}),
         };
         if (includeContinuity) {
             jsonOut.continuity = {
@@ -1242,6 +1321,14 @@ async function cmdRecall(hippoRoot, query, flags) {
         if (recentSessionEvents.length > 0)
             printSessionEvents(recentSessionEvents);
     }
+    // v0.33 / J1 — render anchoring hint above planning-fallacy hint
+    // (anchoring is the stronger cognitive-pull warning so it gets first
+    // position). Hint absent (env disabled, no sessionId, or no R1/R2)
+    // is silent.
+    if (cmdAnchoringHint) {
+        console.log(`[anchored_on: ${cmdAnchoringHint.memoryId}] ${cmdAnchoringHint.summary}`);
+        console.log();
+    }
     // v0.32 / J3.2 — render planning-fallacy hint ABOVE the result list so
     // the agent sees its track record before scrolling. Hint absent (env
     // disabled or no forward-claim match) is silent. detectedPhrase is
@@ -1253,6 +1340,31 @@ async function cmdRecall(hippoRoot, query, flags) {
         console.log(`Planning fallacy hint (class: ${cmdPlanningFallacyHint.classTag}): ${cmdPlanningFallacyHint.baserateSummary} [detected: ${safePhrase}]`);
         console.log();
     }
+    // v1.13.3 / C5 follow-up — Cutoff line ABOVE the result list (was a
+    // "WYSIATI:" line BELOW the result list in v1.12.13-v1.13.2). Dogfood
+    // proof at docs/dogfood/2026-05-27-track-j-warnings.md: a fresh sub-agent
+    // reading the v1.13.2 bottom-placed line ignored it entirely and
+    // summarised the visible memories as if the dropped pool didn't exist
+    // (the exact WYSIATI failure mode C5 is supposed to flag). Top placement
+    // + plain English ("Cutoff:" not "WYSIATI:") closes the read gap.
+    if (showWhy) {
+        const s = cmdSuppressionSummary;
+        const clauses = [];
+        if (s.droppedByBudget > 0)
+            clauses.push(`${s.droppedByBudget} dropped to fit limit`);
+        if (s.droppedPreRank > 0)
+            clauses.push(`${s.droppedPreRank} filtered pre-rank`);
+        if (s.summarySubstitutionsAdded > 0)
+            clauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
+        if (s.freshTailAdded > 0)
+            clauses.push(`${s.freshTailAdded} fresh-tail added`);
+        if (s.suppressedByInterference > 0)
+            clauses.push(`${s.suppressedByInterference} suppressed by interference`);
+        if (clauses.length > 0) {
+            console.log(`Cutoff: showing ${results.length} of ${s.totalCandidates} candidates; ${clauses.join('; ')}.`);
+            console.log();
+        }
+    }
     console.log(`Found ${results.length} memories (${totalTokens} tokens) for: "${query}"\n`);
     for (const r of results) {
         const e = r.entry;
@@ -1287,30 +1399,9 @@ async function cmdRecall(hippoRoot, query, flags) {
         console.log(e.content);
         console.log();
     }
-    // v1.12.13 / C5 — WYSIATI cutoff transparency in --why text output.
-    // Single-line summary after the result list, emitted only when --why is
-    // set AND at least one counter is non-zero. Skip zero-count clauses to
-    // keep the line tight. The calling agent uses this to spot when the
-    // shown set is a small slice of a much larger candidate pool (Kahneman
-    // "What You See Is All There Is" failure mode).
-    if (showWhy) {
-        const s = cmdSuppressionSummary;
-        const clauses = [];
-        if (s.droppedByBudget > 0)
-            clauses.push(`${s.droppedByBudget} dropped by limit`);
-        if (s.droppedPreRank > 0)
-            clauses.push(`${s.droppedPreRank} pre-rank filtered`);
-        if (s.summarySubstitutionsAdded > 0)
-            clauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
-        if (s.freshTailAdded > 0)
-            clauses.push(`${s.freshTailAdded} fresh-tail added`);
-        if (s.suppressedByInterference > 0)
-            clauses.push(`${s.suppressedByInterference} suppressed by interference`);
-        if (clauses.length > 0) {
-            console.log(`WYSIATI: showing ${results.length}/${s.totalCandidates}; ${clauses.join('; ')}.`);
-            console.log();
-        }
-    }
+    // v1.12.13 / C5 -> v1.13.3 follow-up: the WYSIATI bottom block was
+    // moved above the result list (see comment near the Cutoff render
+    // above). Function ends here.
 }
 async function cmdExplain(hippoRoot, query, flags) {
     requireInit(hippoRoot);
@@ -4560,6 +4651,9 @@ const VALID_AUDIT_OPS = new Set([
     'recall_autodebias_hint', // v0.32 / J3.2 — emitted by computePlanningFallacyHint on success
     'recall_autodebias_hint_no_class_match', // v0.32 / J3.2 — telemetry: forward-claim, no class scored
     'recall_autodebias_hint_tiebreak', // v0.32 / J3.2 — telemetry: forward-claim, >=2 classes tied
+    'recall_anchor_detected_query_repeat', // v0.33 / J1 — emitted by detector on R1 fire
+    'recall_anchor_detected_memory_dominance', // v0.33 / J1 — emitted by detector on R2 fire
+    'recall_anchor_skipped_no_session', // v0.33 / J1 — telemetry: no sessionId, ring skipped
 ]);
 function formatAuditRow(ev) {
     const target = ev.targetId ?? '-';