hippo-memory 0.30.0 → 0.31.0

package/README.md

@@ -60,6 +60,18 @@ 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.
+- **`hippo status` prints a `Trace:` counter.** The new layer is visible in status output.
+- **`hippo --version` / `-v`** works as expected. Previously errored.
+
 ### What's new in v0.30.0
 
 - **Sequence binding for recursive-self-improvement agents.** New `Layer.Trace` memories store ordered `A → B → C → outcome` traces. Agents can `hippo trace record` explicitly, or just call `hippo session complete --outcome success` and let `hippo sleep` auto-promote completed sessions into queryable traces.

package/dist/cli.js

@@ -28,6 +28,7 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
+import { fileURLToPath } from 'node:url';
 import { execFileSync, execSync, spawn } from 'child_process';
 import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, uninstallCodexWrapper, resolveCodexSessionTranscript, resolveCodexWrapperPaths, } from './hooks.js';
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, applyOutcome, computeSchemaFit, Layer, DECISION_HALF_LIFE_DAYS, } from './memory.js';
@@ -43,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';
@@ -412,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] ' : '';
@@ -458,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, {
@@ -465,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.
@@ -494,6 +507,16 @@ async function cmdRecall(hippoRoot, query, flags) {
             return r.entry.trace_outcome === outcomeFilter;
         });
     }
+    // --layer filter: strict, drops entries whose layer does not match.
+    const layerFilter = flags['layer'] !== undefined ? String(flags['layer']).trim() : '';
+    if (layerFilter) {
+        const validLayers = Object.values(Layer);
+        if (!validLayers.includes(layerFilter)) {
+            console.error(`Invalid --layer: "${layerFilter}". Must be one of: ${validLayers.join(', ')}.`);
+            process.exit(1);
+        }
+        results = results.filter((r) => r.entry.layer === layerFilter);
+    }
     if (limit < results.length) {
         results = results.slice(0, limit);
     }
@@ -591,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) {
@@ -599,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';
     }
@@ -680,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)
@@ -1586,6 +1614,7 @@ function cmdStatus(hippoRoot) {
     console.log(`  Buffer:          ${byLayer[Layer.Buffer]}`);
     console.log(`  Episodic:        ${byLayer[Layer.Episodic]}`);
     console.log(`  Semantic:        ${byLayer[Layer.Semantic]}`);
+    console.log(`  Trace:           ${byLayer[Layer.Trace]}`);
     const conflictCount = listMemoryConflicts(hippoRoot).length;
     console.log(`Pinned:            ${pinned}`);
     console.log(`At risk (<0.2):    ${atRisk}`);
@@ -2178,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;
@@ -2227,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) {
@@ -2275,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,
@@ -2288,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,
@@ -3468,6 +3503,21 @@ Examples:
 const { command, args, flags } = parseArgs(process.argv);
 const hippoRoot = getHippoRoot(process.cwd());
 async function main() {
+    if (command === '--version' || command === '-v' || flags['version']) {
+        const __filename_local = fileURLToPath(import.meta.url);
+        const __dirname_local = path.dirname(__filename_local);
+        const pkgPath = path.join(__dirname_local, '..', 'package.json');
+        let pkgJson;
+        try {
+            pkgJson = fs.readFileSync(pkgPath, 'utf-8');
+        }
+        catch {
+            pkgJson = fs.readFileSync(path.join(__dirname_local, '..', '..', 'package.json'), 'utf-8');
+        }
+        const { version } = JSON.parse(pkgJson);
+        console.log(version);
+        process.exit(0);
+    }
     maybeAutoInstallCodexWrapper(command, args);
     switch (command) {
         case 'init':