hippo-memory 1.7.4 → 1.7.6

package/README.md

@@ -85,6 +85,20 @@ hippo recall "data pipeline issues" --budget 2000
 
 ---
 
+### What's new in v1.7.6
+
+- **Fresh-tail pinned context injection.** `hippo context --pinned-only --include-recent <n>` now includes the last N writes regardless of pinning, so memories saved mid-session can appear in the next Claude Code `UserPromptSubmit` injection before they are explicitly pinned. New Claude hook installs use `--include-recent 5`; legacy pinned-only hooks are migrated on `hippo hook install`.
+- **Calibration sweep on the sequential-learning benchmark.** Adds `--budget` plumbing through the runner + a calibration script (`calibrate.mjs`) with a mechanical B* selection rule. Used to test "would smaller budget recover headroom for the goal-stack hypothesis?" on the v1.7.5 floor.
+- **Calibration verdict: budget reduction does not produce a discriminating workload.** 5 budgets × 10 seeds = 50 single-seed runs all returned 0% late-phase trap rate. Floor effect is structural, not budget-tunable. B\* = NULL. Per pre-registered escalation, v1.7.7 will sweep `--restrict-late-to last-4` instead.
+- **Bug-fix on `calibrate.mjs` starvation guard.** Read a non-existent JSON field; false-positive `starved=true` on every candidate. Did not affect the verdict (lateMean=0% was load-bearing). Fix: drop the broken extraction.
+- **Hypothesis still untested.** The −10pp goal-stack lift claim remains unsupported by a discriminating workload. Mechanism still shipped from v1.7.4. Honest reporting: see `docs/evals/2026-05-09-v1.7.6-calibration-result.md`.
+
+### What's new in v1.7.5
+
+- **Sequential-learning benchmark gains `pushGoal`/`completeGoal` hooks** + a multi-seed eval harness with seeded category-to-slot variance, exact paired permutation CI, and `--eval-strict` mode. The dlPFC goal-stack mechanism is now exercisable on the public benchmark.
+- **Tag-fix on memory store** so the goal-stack boost can actually match. Pre-fix the boost would have matched zero memories.
+- **Eval ran but stopped per pre-registered sanity gate.** Both hippo-base and hippo+goal-stack hit 0% late-phase trap rate across 20 seeds — floor effect prevents H1/H0 discrimination. The −10pp hypothesis remains untested on a discriminating workload. Mechanism shipped, hypothesis open. Pre-reg + result in `docs/evals/`.
+
 ### What's new in v1.7.4
 
 - **Goal-stack boost on MCP + HTTP.** Set `RecallOpts.sessionId` (or HTTP `?session_id=...`, or MCP `hippo_recall { session_id }`) and the dlPFC goal-stack boost — previously CLI-only — applies on MCP and HTTP too. Both `api.recall` (primary BM25 band, before fresh-tail / summary appendix) AND MCP's separate `physicsSearch`/`hybridSearch` path are boosted. New `RecallOpts.goalTag` lets callers opt out per-call.
@@ -797,7 +811,7 @@ This adds a `<!-- hippo:start -->` ... `<!-- hippo:end -->` block that tells the
 For Claude Code, it also adds:
 - a `SessionEnd` hook so `hippo sleep` runs automatically when the session exits
 - a `SessionStart` hook that prints the previous session's consolidation output
-- a `UserPromptSubmit` hook that re-injects pinned memories (`hippo remember <text> --pin`) into every turn's context — so invariants survive long sessions where Opus 4.7 might otherwise "forget" them. Budget: 500 tokens per turn, skipped entirely when no pinned memories exist. Opt out with `{"pinnedInject":{"enabled":false}}` in `.hippo/config.json`.
+- a `UserPromptSubmit` hook that runs `hippo context --pinned-only --include-recent 5 --format additional-context` every turn. It re-injects pinned memories (`hippo remember <text> --pin`) plus the last 5 writes, so fresh same-session lessons appear on the next prompt before you pin them. Opt out with `{"pinnedInject":{"enabled":false}}` in `.hippo/config.json`.
 
 To remove: `hippo hook uninstall claude-code`
 

package/dist/cli.js

@@ -79,6 +79,12 @@ function parseLimitFlag(value) {
     const parsed = parseInt(String(value), 10);
     return Number.isFinite(parsed) && parsed >= 1 ? parsed : Infinity;
 }
+function parseCountFlag(value) {
+    if (!value || value === true || Array.isArray(value))
+        return 0;
+    const parsed = parseInt(String(value), 10);
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : 0;
+}
 /**
  * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
  * connection so callers don't have to thread a db handle. Swallows all errors
@@ -2823,6 +2829,7 @@ async function cmdContext(hippoRoot, args, flags) {
     }
     const budget = parseInt(String(flags['budget'] ?? '1500'), 10);
     const limit = parseLimitFlag(flags['limit']);
+    const includeRecent = parseCountFlag(flags['include-recent']);
     const ctxExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
     const ctxActiveScope = ctxExplicitScope || detectScope();
     // If budget is 0, skip entirely (zero token cost)
@@ -2874,11 +2881,39 @@ async function cmdContext(hippoRoot, args, flags) {
             return; // user disabled via config
         // Effective budget: explicit --budget wins over config.
         const effBudget = flags['budget'] !== undefined ? budget : pinnedCfg.pinnedInject.budget;
+        const nowP = new Date();
+        const selectedIds = new Set();
+        let usedP = 0;
+        if (includeRecent > 0) {
+            const recent = [
+                ...localEntries.map((entry) => ({ entry, isGlobal: false })),
+                ...globalEntries.map((entry) => ({ entry, isGlobal: true })),
+            ]
+                .sort((a, b) => {
+                const byCreated = Date.parse(b.entry.created) - Date.parse(a.entry.created);
+                return byCreated !== 0 ? byCreated : b.entry.id.localeCompare(a.entry.id);
+            })
+                .slice(0, includeRecent)
+                .map(({ entry, isGlobal }) => ({
+                entry,
+                score: calculateStrength(entry, nowP) * (isGlobal ? 1 / 1.2 : 1),
+                tokens: estimateTokens(entry.content),
+                isGlobal,
+            }));
+            for (const r of recent) {
+                if (selectedIds.has(r.entry.id))
+                    continue;
+                if (usedP + r.tokens > effBudget)
+                    continue;
+                selectedItems.push(r);
+                selectedIds.add(r.entry.id);
+                usedP += r.tokens;
+            }
+        }
         const pinnedLocal = localEntries.filter((e) => e.pinned);
         const pinnedGlobal = globalEntries.filter((e) => e.pinned);
-        if (pinnedLocal.length === 0 && pinnedGlobal.length === 0)
+        if (pinnedLocal.length === 0 && pinnedGlobal.length === 0 && selectedItems.length === 0)
             return; // zero output
-        const nowP = new Date();
         const rankedPinned = [
             ...pinnedLocal.map((e) => ({ entry: e, isGlobal: false })),
             ...pinnedGlobal.map((e) => ({ entry: e, isGlobal: true })),
@@ -2894,11 +2929,13 @@ async function cmdContext(hippoRoot, args, flags) {
             };
         })
             .sort((a, b) => b.score - a.score);
-        let usedP = 0;
         for (const r of rankedPinned) {
+            if (selectedIds.has(r.entry.id))
+                continue;
             if (usedP + r.tokens > effBudget)
                 continue;
             selectedItems.push(r);
+            selectedIds.add(r.entry.id);
             usedP += r.tokens;
         }
         totalTokens = usedP;
@@ -4673,6 +4710,7 @@ Commands:
     --auto                 Auto-detect task from git state
     --budget <n>           Token budget (default: 1500)
     --pinned-only          Only inject pinned memories (used by UserPromptSubmit hook)
+    --include-recent <n>   With --pinned-only, also inject the last N writes regardless of pinning
     --format <fmt>         Output format: markdown (default), json, or additional-context (Claude Code hook JSON)
     --framing <mode>       Framing: observe (default), suggest, assert
   sleep                    Run consolidation pass (auto-learns + dedup + auto-shares)