hippo-memory 0.30.1 → 0.31.0

package/README.md

@@ -60,6 +60,12 @@ hippo recall "data pipeline issues" --budget 2000
 
 ---
 
+### What's new in v0.31.0
+
+- **Scope-aware corrections.** Tag a memory with `hippo remember --scope plan-eng-review` and it only surfaces strongly when that scope is active again. Matching scope gets 1.5x boost, mismatching scope is suppressed 0.5x, unscoped memories stay neutral. Corrections said during one skill stop polluting unrelated contexts.
+- **Auto-detect from env.** `HIPPO_SCOPE`, `GSTACK_SKILL`, `OPENCLAW_SKILL` populate the scope automatically. Explicit `--scope` on any command overrides.
+- **`hippo explain --why`** now shows the `scope:` multiplier when it fires, so you can see why a memory got ranked up or down.
+
 ### What's new in v0.30.1
 
 - **`hippo recall --layer <L>` is now a strict filter.** Previously the flag was accepted but silently dropped; other layers leaked into results. The RSI demo's `recall --layer trace` now does what it says.

package/dist/cli.js

@@ -44,6 +44,7 @@ import { openHippoDb, closeHippoDb } from './db.js';
 import { captureError, extractLessons, deduplicateLesson, runWatched, fetchGitLog, isGitRepo, } from './autolearn.js';
 import { extractInvalidationTarget, invalidateMatching } from './invalidation.js';
 import { extractPathTags } from './path-context.js';
+import { detectScope, scopeMatch } from './scope.js';
 import { getGlobalRoot, initGlobal, promoteToGlobal, shareMemory, listPeers, autoShare, transferScore, searchBothHybrid, syncGlobalToLocal, } from './shared.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, listRegisteredWorkspaces, registerWorkspace, runDailyMaintenance, } from './scheduler.js';
 import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, } from './importers.js';
@@ -413,6 +414,14 @@ function cmdRemember(hippoRoot, text, flags) {
         if (!entry.tags.includes(pt))
             entry.tags.push(pt);
     }
+    // Scope tagging: explicit --scope or auto-detected
+    const explicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    const activeScope = explicitScope || detectScope();
+    if (activeScope) {
+        const scopeTag = `scope:${activeScope}`;
+        if (!entry.tags.includes(scopeTag))
+            entry.tags.push(scopeTag);
+    }
     writeEntry(targetRoot, entry);
     updateStats(targetRoot, { remembered: 1 });
     const prefix = useGlobal ? '[global] ' : '';
@@ -459,6 +468,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;
+    const recallActiveScope = recallExplicitScope || detectScope();
     let results;
     if (usePhysics && !hasGlobal) {
         results = await physicsSearch(query, localEntries, {
@@ -466,17 +477,18 @@ async function cmdRecall(hippoRoot, query, flags) {
             hippoRoot,
             physicsConfig: config.physics,
             minResults,
+            scope: recallActiveScope,
         });
     }
     else if (hasGlobal) {
         // Use searchBothHybrid for merged results with embedding support
         results = await searchBothHybrid(query, hippoRoot, globalRoot, {
-            budget, mmr: mmrEnabled, mmrLambda, localBump, minResults,
+            budget, mmr: mmrEnabled, mmrLambda, localBump, minResults, scope: recallActiveScope,
         });
     }
     else {
         results = await hybridSearch(query, localEntries, {
-            budget, hippoRoot, mmr: mmrEnabled, mmrLambda, minResults,
+            budget, hippoRoot, mmr: mmrEnabled, mmrLambda, minResults, scope: recallActiveScope,
         });
     }
     // --outcome filter: drop trace entries whose trace_outcome !== target.
@@ -602,6 +614,8 @@ 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;
+    const explainActiveScope = explainExplicitScope || detectScope();
     let results;
     let modeUsed;
     if (usePhysics && !hasGlobal) {
@@ -610,18 +624,19 @@ async function cmdExplain(hippoRoot, query, flags) {
             hippoRoot,
             physicsConfig: config.physics,
             explain: true,
+            scope: explainActiveScope,
         });
         modeUsed = 'physics';
     }
     else if (hasGlobal) {
         results = await searchBothHybrid(query, hippoRoot, globalRoot, {
-            budget, explain: true, mmr: mmrEnabled, mmrLambda, localBump,
+            budget, explain: true, mmr: mmrEnabled, mmrLambda, localBump, scope: explainActiveScope,
         });
         modeUsed = 'searchBothHybrid';
     }
     else {
         results = await hybridSearch(query, localEntries, {
-            budget, hippoRoot, explain: true, mmr: mmrEnabled, mmrLambda,
+            budget, hippoRoot, explain: true, mmr: mmrEnabled, mmrLambda, scope: explainActiveScope,
         });
         modeUsed = 'hybrid';
     }
@@ -691,6 +706,8 @@ async function cmdExplain(hippoRoot, query, flags) {
             console.log(`    recency:   x${fmt(b.recencyMultiplier, 3)}  (age=${b.ageDays}d)`);
             if (b.decisionBoost !== 1)
                 console.log(`    decision:  x${fmt(b.decisionBoost, 2)}  (tagged 'decision')`);
+            if (b.scopeBoost !== 1)
+                console.log(`    scope:     x${fmt(b.scopeBoost, 2)}  (scope tag ${b.scopeBoost > 1 ? 'match' : 'mismatch'})`);
             if (b.pathBoost !== 1)
                 console.log(`    path:      x${fmt(b.pathBoost, 3)}  (cwd path tag overlap)`);
             if (b.sourceBump !== 1)
@@ -2190,6 +2207,8 @@ async function cmdContext(hippoRoot, args, flags) {
     }
     const budget = parseInt(String(flags['budget'] ?? '1500'), 10);
     const limit = parseLimitFlag(flags['limit']);
+    const ctxExplicitScope = flags['scope'] !== undefined ? String(flags['scope']).trim() : null;
+    const ctxActiveScope = ctxExplicitScope || detectScope();
     // If budget is 0, skip entirely (zero token cost)
     if (budget <= 0)
         return;
@@ -2239,12 +2258,16 @@ async function cmdContext(hippoRoot, args, flags) {
             ...pinnedLocal.map((e) => ({ entry: e, isGlobal: false })),
             ...pinnedGlobal.map((e) => ({ entry: e, isGlobal: true })),
         ]
-            .map(({ entry, isGlobal }) => ({
-            entry,
-            score: calculateStrength(entry, nowP) * (isGlobal ? 1 / 1.2 : 1),
-            tokens: estimateTokens(entry.content),
-            isGlobal,
-        }))
+            .map(({ entry, isGlobal }) => {
+            const scopeSig = scopeMatch(entry.tags, ctxActiveScope);
+            const sBst = scopeSig === 1 ? 1.5 : scopeSig === -1 ? 0.5 : 1.0;
+            return {
+                entry,
+                score: calculateStrength(entry, nowP) * (isGlobal ? 1 / 1.2 : 1) * sBst,
+                tokens: estimateTokens(entry.content),
+                isGlobal,
+            };
+        })
             .sort((a, b) => b.score - a.score);
         let usedP = 0;
         for (const r of rankedPinned) {
@@ -2287,7 +2310,7 @@ async function cmdContext(hippoRoot, args, flags) {
     else {
         let results;
         if (hasGlobal) {
-            const merged = await searchBothHybrid(query, hippoRoot, globalRoot, { budget });
+            const merged = await searchBothHybrid(query, hippoRoot, globalRoot, { budget, scope: ctxActiveScope });
             const localIndex = loadIndex(hippoRoot);
             results = merged.map((r) => ({
                 entry: r.entry,
@@ -2300,8 +2323,8 @@ async function cmdContext(hippoRoot, args, flags) {
             const ctxConfig = loadConfig(hippoRoot);
             const usePhysicsCtx = ctxConfig.physics?.enabled !== false;
             const ctxResults = usePhysicsCtx
-                ? await physicsSearch(query, localEntries, { budget, hippoRoot, physicsConfig: ctxConfig.physics })
-                : await hybridSearch(query, localEntries, { budget, hippoRoot });
+                ? await physicsSearch(query, localEntries, { budget, hippoRoot, physicsConfig: ctxConfig.physics, scope: ctxActiveScope })
+                : await hybridSearch(query, localEntries, { budget, hippoRoot, scope: ctxActiveScope });
             results = ctxResults.map((r) => ({
                 entry: r.entry,
                 score: r.score,