hippo-memory 1.52.4 → 1.52.6

package/README.md

@@ -830,17 +830,17 @@ For how these mechanisms connect to LLM training, continual learning, and open r
 
 ## Comparison
 
-The AI-memory category matured fast in 2026. Hippo's specific take — bio-decay, strengthen-on-use, outcome-weighted half-lives — is one stance among several. The table below is a feature snapshot, not a verdict: graph-first systems ([gbrain](https://hermesatlas.com/projects/garrytan/gbrain), [Zep](https://www.getzep.com/), [Cognee](https://www.cognee.ai/)), agent-managed systems ([Letta](https://github.com/letta-ai/letta)), and version-control / skill-distillation takes ([Memoria](https://github.com/matrixorigin/Memoria), [EverMind](https://evermind.ai/)) all solve adjacent problems with different mechanics.
+The AI-memory category matured fast in 2026. Hippo's specific take — bio-decay, strengthen-on-use, outcome-weighted half-lives — is one stance among several. The table below is a feature snapshot, not a verdict: graph-first systems ([gbrain](https://hermesatlas.com/projects/garrytan/gbrain), [Zep](https://www.getzep.com/), [Cognee](https://www.cognee.ai/)), agent-managed systems ([Letta](https://github.com/letta-ai/letta-code)), and version-control / skill-distillation takes ([Memoria](https://github.com/matrixorigin/Memoria), [EverMind](https://evermind.ai/)) all solve adjacent problems with different mechanics.
 
-| Feature | Hippo | [MemPalace](https://github.com/milla-jovovich/mempalace) | [Mem0](https://github.com/mem0ai/mem0) | [Basic Memory](https://github.com/basicmachines-co/basic-memory) | [gbrain](https://hermesatlas.com/projects/garrytan/gbrain) | [Zep](https://www.getzep.com/) | [Letta](https://github.com/letta-ai/letta) | [Cognee](https://www.cognee.ai/) | [Memoria](https://github.com/matrixorigin/Memoria) | [EverMind](https://evermind.ai/) |
+| Feature | Hippo | [MemPalace](https://github.com/milla-jovovich/mempalace) | [Mem0](https://github.com/mem0ai/mem0) | [Basic Memory](https://github.com/basicmachines-co/basic-memory) | [gbrain](https://hermesatlas.com/projects/garrytan/gbrain) | [Zep](https://www.getzep.com/) | [Letta](https://github.com/letta-ai/letta-code) | [Cognee](https://www.cognee.ai/) | [Memoria](https://github.com/matrixorigin/Memoria) | [EverMind](https://evermind.ai/) |
 |---------|-------|-----------|------|-------------|--------|-----|-------|--------|---------|----------|
 | Decay by default | Yes | No | No | No | No | No | No | No | No | No |
 | Retrieval strengthening | Yes | No | No | No | No | No | No | Partial (recall tuning) | No | Partial (Skill Memory distills patterns) |
 | Reward-proportional decay | Yes | No | No | No | No | No | No | No | No | No |
-| Hybrid search (BM25 + embeddings) | Yes | Embeddings + spatial | Embeddings only | No | Yes (vec + rerank + graph) | Yes (graph + vec) | ? | Yes (GraphRAG) | Yes (vector + full-text) | Yes (mRAG, multi-modal) |
-| Schema acceleration / knowledge graph | Yes (schema) | No | No | No | Yes (typed KG, self-wiring) | Yes (temporal KG) | No | Yes (auto-ontologies) | No (typed claims) | Yes (hierarchical: user/group/agent) |
-| Conflict detection + resolution | Yes | No | No | No | Yes (eval-surfaced) | Yes (auto-invalidate stale facts) | No | No | Yes (auto-detect + quarantine) | Partial (temporal tracking) |
-| Multi-agent shared memory | Yes | No | No | No | Yes (brain repo, team mounts) | Yes | No (single-agent state) | Yes | Yes (branch/merge across sessions) | Yes (multi-agent coordination) |
+| Hybrid search (BM25 + embeddings) | Yes | Embeddings + spatial | Yes (semantic + BM25 + entity) | No | Yes (vec + rerank + graph) | Yes (graph + vec) | ? | Yes (GraphRAG) | Yes (vector + full-text) | Yes (mRAG, multi-modal) |
+| Schema acceleration / knowledge graph | Yes (schema) | No | Partial (entity linking; graph memory on Pro) | No | Yes (typed KG, self-wiring) | Yes (temporal KG) | No | Yes (auto-ontologies) | No (typed claims) | Yes (hierarchical: user/group/agent) |
+| Conflict detection + resolution | Yes | No | Partial (hosted platform marks superseded facts) | No | Yes (eval-surfaced) | Yes (auto-invalidate stale facts) | No | No | Yes (auto-detect + quarantine) | Partial (temporal tracking) |
+| Multi-agent shared memory | Yes | No | No | No | Yes (brain repo, team mounts) | Yes | Yes (shared memory blocks) | Yes | Yes (branch/merge across sessions) | Yes (multi-agent coordination) |
 | Transfer scoring | Yes | No | No | No | No | No | No | No | No | No |
 | Outcome tracking | Yes | No | No | No | No | No | No | No | No | Partial (Cases: agent trajectories) |
 | Confidence tiers | Yes | No | No | No | No (typed facts) | No | No | No | No | No |
@@ -848,16 +848,16 @@ The AI-memory category matured fast in 2026. Hippo's specific take — bio-decay
 | Lossless compression | No | Yes (AAAK, 30x) | No | No | No | No | No | No | No | No |
 | Cross-tool import (ChatGPT/Claude/Cursor) | Yes | No | No | No | Partial (data sources) | ? | No | Partial (28 data sources) | No (Git ops) | Partial (mRAG: PDFs/images/URLs) |
 | Auto-hook install | Yes | No | No | No | No | No | No | No | No | No |
-| MCP server | Yes | Yes | Yes (hosted, needs an account) | Yes | Yes (stdio + HTTP/OAuth) | Partial (managed) | Yes (via Letta Code) | Yes (first-party Claude/LangGraph) | Yes | ? |
-| Zero runtime deps | Yes | No (ChromaDB) | No | No | No (PGLite or PG+pgvector) | No (managed service) | No (Python deps) | No (Python deps) | Yes (single Rust binary) | No (managed + OSS) |
-| LongMemEval (best published) | 98.0% local / 99.8% voyage R@5 (s_cleaned, per-haystack)\* | 96.6% raw / 100% reranked R@5 | ~49-85% R@5 | N/A | 97.6-97.9% R@5 (s_cleaned\*) | N/A (LoCoMo 80.3%) | N/A | N/A | 88.78% overall accuracy w/ reader\*\* | 83.00% overall\*\* (LoCoMo 93.05%, HaluMem 93.04%) |
-| Git-friendly | Yes | No | No | Yes | Yes | No | No | No | Yes (Git is the model) | ? |
+| MCP server | Yes | Yes | Yes (hosted, needs an account) | Yes | Yes (stdio + HTTP/OAuth) | Yes (hosted, needs an account) | Yes (hosted, needs an API key) | Yes (first-party Claude/LangGraph) | Yes | ? |
+| Zero runtime deps | Yes | No (ChromaDB) | No | No | No (PGLite or PG+pgvector) | No (managed service) | No (npm deps) | No (Python deps) | Yes (single Rust binary) | No (managed + OSS) |
+| LongMemEval (best published) | 98.0% local / 99.8% voyage R@5 (s_cleaned, per-haystack)\* | 96.6% raw / 100% reranked R@5 | 94.4 (hosted platform)\*\* | N/A | 97.6-97.9% R@5 (s_cleaned\*) | 90.2% accuracy\*\* (LoCoMo 94.7%) | N/A | N/A | 88.78% overall accuracy w/ reader\*\* | 83.00% overall\*\* (LoCoMo 93.05%, HaluMem 93.04%) |
+| Git-friendly | Yes | No | No | Yes | Yes | No | Yes (memory tracked in git) | No | Yes (Git is the model) | ? |
 | Framework agnostic | Yes | Yes | Partial | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| License | MIT | (open) | Apache-2.0 | (open) | MIT | Apache-2.0 (community) | Apache-2.0 | MIT (core) | Apache-2.0 | Apache-2.0 (OSS) + cloud |
+| License | MIT | (open) | Apache-2.0 | (open) | MIT | Proprietary cloud (Graphiti: Apache-2.0) | Apache-2.0 | MIT (core) | Apache-2.0 | Apache-2.0 (OSS) + cloud |
 
 \* Hippo's 98.0% uses the free local MiniLM embedder (an optional install) and 99.8% uses voyage-3-large (measured 2026-06-09, not re-run). Both are on `longmemeval_s_cleaned` with a per-question haystack, the split and metric of gbrain's published 97.6%. Each is the best of five retrieval settings in the benchmark scripts, not `hippo recall`. At 500 questions the 95% interval is about ±1.2 points, so 98.0 and 97.6 are a tie. The June 2026 build scored 98.6; [`docs/evals/2026-09-23-longmemeval-reproduction.md`](docs/evals/2026-09-23-longmemeval-reproduction.md) has both runs. An older hippo number, 86.8% R@5 on `longmemeval_oracle` under pooled (non-per-haystack) retrieval, is not comparable to per-haystack figures.
 
-\*\* Different metric: Memoria's 88.78% and EverMind's 83% are reported as overall accuracy with a reader LLM, not retrieval R@5. Higher denominator + LLM helps. Not directly comparable to retrieval-only R@5 numbers above.
+\*\* Different metric: these are end-to-end answer scores, not retrieval R@5. Mem0's 94.4 comes from its hosted platform, which its README says includes optimizations the open-source SDK lacks. Zep's 90.2% and 94.7% are accuracy figures from its homepage. Memoria's 88.78% and EverMind's 83% are overall accuracy with a reader LLM. Higher denominator + LLM helps. Not directly comparable to retrieval-only R@5 numbers above. The Mem0, Zep and Letta columns were last checked against each vendor's own pages on 2026-09-28.
 
 Different tools answer different questions. Mem0 and Basic Memory implement "save everything, search later." MemPalace implements "store everything, organize spatially for retrieval." gbrain, Zep, and Cognee implement "extract typed entities and relationships into a knowledge graph." Letta implements "the agent edits its own memory blocks." Memoria implements "Git-style version control over the memory state itself." EverMind implements "self-evolving Skill Memory + multi-modal retrieval over hierarchical scopes." Hippo implements "learn what is wrong and stop repeating it." These are complementary takes, not a single-axis ranking: bio-lifecycle (Hippo) + GraphRAG (gbrain/Cognee/Zep) + agent-self-edit (Letta) + memory-VCS (Memoria) + skill-distillation (EverMind) cover different parts of the same problem.
 

package/dist/cli.d.ts

@@ -65,5 +65,7 @@ export declare function printContextMarkdown(items: Array<{
     showStrength?: boolean;
     heading?: string;
 }): void;
+export declare function usageText(): string;
+export declare function verbUsage(verb: string): string | null;
 export declare function runCli(argv?: string[]): Promise<void>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -138,7 +138,7 @@ import { listDlq, replayDlqEntry } from './connectors/slack/dlq.js';
 import { backfillChannel } from './connectors/slack/backfill.js';
 import { slackHistoryFetcher } from './connectors/slack/web-client.js';
 import { addWorkspace as addSlackWorkspace, listWorkspaces as listSlackWorkspaces, removeWorkspace as removeSlackWorkspace, } from './connectors/slack/workspaces.js';
-import { cmdGithub } from './connectors/github/cli-impl.js';
+import { cmdGithub, printGithubBackfillUsage } from './connectors/github/cli-impl.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -392,6 +392,11 @@ export function parseArgs(argv) {
                 i += 2;
             }
         }
+        else if (part === '-h') {
+            // Running a verb when help was asked costs more than losing a literal -h; `-- -h` still passes one.
+            flags['help'] = true;
+            i++;
+        }
         else {
             args.push(part);
             i++;
@@ -8168,10 +8173,6 @@ function printAuditPruneUsage() {
     console.log('  --json             Output the result as JSON {cutoff, count, dryRun}.');
 }
 function cmdAuditPrune(hippoRoot, flags) {
-    if (flags['help']) {
-        printAuditPruneUsage();
-        return;
-    }
     const olderThanRaw = typeof flags['older-than'] === 'string' ? flags['older-than'] : '';
     if (!olderThanRaw) {
         console.error('Usage: hippo audit prune --older-than <Nd> [--dry-run] [--tenant <t>]');
@@ -8474,12 +8475,6 @@ function printSlackBackfillUsage() {
     console.log('  --since    backfill from ISO timestamp (default: cursor)');
 }
 function cmdSlackBackfill(hippoRoot, flags) {
-    // M3: detect --help BEFORE token check so operators can read usage in
-    // environments without SLACK_BOT_TOKEN configured.
-    if (flags['help']) {
-        printSlackBackfillUsage();
-        return;
-    }
     const channel = typeof flags['channel'] === 'string' ? flags['channel'] : undefined;
     if (!channel) {
         printSlackBackfillUsage();
@@ -8557,10 +8552,6 @@ function printSlackWorkspacesUsage() {
     console.log('  remove --team <T>             Remove a workspace registration');
 }
 function cmdSlackWorkspacesAdd(hippoRoot, flags) {
-    if (flags['help']) {
-        printSlackWorkspacesUsage();
-        return;
-    }
     const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
     const tenantId = typeof flags['tenant'] === 'string' ? flags['tenant'].trim() : '';
     if (!teamId || !tenantId) {
@@ -8593,10 +8584,6 @@ function cmdSlackWorkspacesList(hippoRoot) {
     }
 }
 function cmdSlackWorkspacesRemove(hippoRoot, flags) {
-    if (flags['help']) {
-        printSlackWorkspacesUsage();
-        return;
-    }
     const teamId = typeof flags['team'] === 'string' ? flags['team'].trim() : '';
     if (!teamId) {
         console.error('Usage: hippo slack workspaces remove --team <T>');
@@ -8649,9 +8636,9 @@ function cmdSlack(hippoRoot, args, flags) {
     console.error('Usage: hippo slack <backfill|dlq list|dlq replay <id> [--force]|workspaces add|workspaces list|workspaces remove> [...]');
     process.exit(1);
 }
-function printUsage() {
-    console.log(`
-Hippo - biologically-inspired memory system for AI agents
+export function usageText() {
+    return `
+Hippo - memory for AI agents that learns what is wrong and stops repeating it
 
 Usage: hippo <command> [options]
 
@@ -8671,6 +8658,10 @@ Commands:
     --observed             Set confidence: observed
     --inferred             Set confidence: inferred
     --global               Store in global store ($HIPPO_HOME or ~/.hippo/)
+  supersede <id> "<text>"  Replace a memory with a new version; the old one points at it
+    --layer <layer>        Layer for the new memory (default: the old memory's layer)
+    --tag <tag>            Tag for the new memory (repeatable; default: the old memory's tags)
+    --pin                  Pin the new memory (default: pinned if the old one was)
   recall <query>           Search and retrieve memories (local + global)
     --budget <n>           Token budget (default: 4000)
     --min-results <n>      Minimum results regardless of budget (default: 1)
@@ -8806,9 +8797,19 @@ Commands:
     dlq list               List DLQ entries for the active tenant
     dlq replay <id> [--force]
                            Re-ingest a DLQ entry (--force skips sig check)
+  slack                    Slack connector subcommands (backfill, dlq, workspaces)
+    backfill --channel <id> [--since ISO]
+                           Backfill a channel's history (needs SLACK_BOT_TOKEN)
+    dlq list               List DLQ entries for the active tenant
+    dlq replay <id> [--force]
+                           Re-ingest a DLQ entry (--force skips sig check)
+    workspaces <add|list|remove>
+                           Map Slack workspaces (team ids) to tenants
   provenance               Provenance coverage gate for kind='raw' rows
     --json                 Output as JSON
     --strict               Exit non-zero when coverage < 100%
+  dag                      Show the summary tree: entity profiles, topic summaries, facts
+    --stats                Count memories per DAG level instead
   drill <summary-id>       Walk down a DAG level-2 summary to its children
     --limit N              Cap children list (default 50)
     --budget N             Cap total child token cost (≈ chars/4)
@@ -8999,6 +9000,8 @@ Commands:
   last-sleep               Print the last 'hippo sleep --log-file' output and clear it
     --path <p>             Log path (default: ~/.hippo/logs/last-sleep.log)
     --keep                 Print without clearing
+  session-end              SessionEnd hook: run sleep, then capture this session, in a detached worker
+    --log-file <path>      Tee the worker's output to a log file (paired with 'hippo last-sleep')
   pre-compact              PreCompact hook: save a working-state snapshot before compaction
     --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)
   compact-resume           SessionStart(compact) hook: re-print the snapshot + session trail
@@ -9013,6 +9016,20 @@ Commands:
                            SessionStart(compact) for mid-session continuity;
                            codex wraps the detected launcher in place
     hook uninstall <target> Remove hook
+  predict "<claim>"        Record a prediction to score against the actual outcome later
+    --class <c>            Reference class (required)
+    --estimate <v>         Numeric estimate
+    --unit <u>             Unit of the estimate
+    --target <YYYY-MM-DD>  When the outcome is due
+  predict close <id>       Close a prediction
+    --state <s>            closed | closed-unknown (required)
+    --actual <v>           The actual value
+    --note "<text>"        Closure note
+  predict list [--class <c>] [--status open|closed|closed-unknown|all] [--limit N]
+                           List predictions (closed and closed-unknown need --class)
+  predict show <id>        Show one prediction
+  predict baserate --class <c>
+                           How past estimates in a class compared with the actuals
   decide "<decision>"      Record a decision (first-class object + memory mirror)
     --context "<why>"      Why this decision was made
     --supersedes <mem-id>  Supersede the decision backed by this memory id
@@ -9124,6 +9141,9 @@ Commands:
   dashboard                Open web dashboard for memory health
     --port <n>             Port to serve on (default: 3333)
   mcp                      Start MCP server (stdio transport)
+  serve                    Start the HTTP API server for this store (Ctrl+C stops it)
+    --port <n>             Port to serve on (default: $HIPPO_PORT or 6789)
+    --host <host>          Address to bind (default: 127.0.0.1)
   goal <sub>               dlPFC goal stack (B3) — scoped per session
     goal push <name>       Push a new active goal; prints the new goal id
       --policy <type>      schema-fit-biased | error-prioritized |
@@ -9221,7 +9241,40 @@ Examples:
   hippo sleep --dry-run
   hippo outcome --good
   hippo status
-`);
+`;
+}
+function printUsage() {
+    console.log(usageText());
+}
+const USAGE_ALIASES = new Map([['project-brief', 'brief'], ['customer-note', 'note']]);
+// Cut from usageText() so a verb's help can never drift from the full listing.
+export function verbUsage(verb) {
+    const name = USAGE_ALIASES.get(verb) ?? verb;
+    const block = [];
+    let inBlock = false;
+    for (const line of usageText().split('\n')) {
+        if (/^ {2}\S/.test(line))
+            inBlock = line.trimStart().split(' ', 1)[0] === name;
+        else if (!line.startsWith('    '))
+            inBlock = false;
+        if (inBlock)
+            block.push(line);
+    }
+    return block.length > 0 ? block.join('\n') : null;
+}
+// These sub-commands have fuller usage text than their lines in usageText().
+const SUBCOMMAND_USAGE = new Map([
+    ['audit prune', printAuditPruneUsage],
+    ['slack backfill', printSlackBackfillUsage],
+    ['slack workspaces', printSlackWorkspacesUsage],
+    ['github backfill', printGithubBackfillUsage],
+]);
+function printHelp(command, args) {
+    const printSubcommandUsage = SUBCOMMAND_USAGE.get(`${command} ${args[0] ?? ''}`);
+    if (printSubcommandUsage)
+        printSubcommandUsage();
+    else
+        console.log(verbUsage(command) ?? usageText());
 }
 // ---------------------------------------------------------------------------
 // Entry point
@@ -9235,6 +9288,15 @@ async function main(command, args, flags, hippoRoot) {
         console.log(version);
         process.exit(0);
     }
+    if (command === '' || command === 'help' || command === '--help' || command === '-h') {
+        printUsage();
+        return;
+    }
+    // Before every other step, so help never opens a store, installs a hook or starts a server.
+    if (Object.hasOwn(flags, 'help')) {
+        printHelp(command, args);
+        return;
+    }
     maybeRepairCodexWrapper(command, flags);
     /** Global --scope well-formedness guard (v1.26.2). parseArgs stores a value-less
      *  flag as boolean true; downstream the 14 consumer sites either coerced that to
@@ -10092,12 +10154,6 @@ async function main(command, args, flags, hippoRoot) {
         case 'graph':
             cmdGraph(hippoRoot, args, flags);
             break;
-        case 'help':
-        case '--help':
-        case '-h':
-        case '':
-            printUsage();
-            break;
         default:
             console.error(`Unknown command: ${command}`);
             printUsage();

package/dist/connectors/github/cli-impl.js

@@ -64,10 +64,6 @@ export function printGithubBackfillUsage() {
  * code path without hitting the network. Defaults to `realGitHubFetcher`.
  */
 export async function cmdGithubBackfill(hippoRoot, flags, fetcher = realGitHubFetcher) {
-    if (flags['help']) {
-        printGithubBackfillUsage();
-        return;
-    }
     const repo = flags['repo'];
     if (!isFlagString(repo) || !repo.includes('/')) {
         printGithubBackfillUsage();

package/dist/support-bundle.js

@@ -224,35 +224,56 @@ const HOME_SPELLINGS = [
     fileUrlPath,
     (p) => p.replace(/[^A-Za-z0-9]/g, '-'),
 ];
-// A Windows separator can be written \, / or JSON-escaped (\\ in a log line quoting JSON), so any of them matches.
-function spellingPattern(spelling) {
+// Git Bash, Cygwin and WSL mount a drive at /c, /cygdrive/c and /mnt/c; a Claude Code folder name writes each / and : as -.
+function mountedDrive(letter) {
+    return `(?:${letter}[:-]|(?:[-/](?:cygdrive|mnt))?[-/]${letter})`;
+}
+/** Regex source for one spelling of the home, or null when too little of it is left to swap safely. */
+function spellingPattern(spelling, deep) {
     if (process.platform !== 'win32')
-        return escapeRegExp(spelling);
-    return spelling.split(/[\\/]+/).map(escapeRegExp).join('(?:\\\\+|/)');
+        return spelling.length >= 3 ? escapeRegExp(spelling) : null;
+    // Each tool that mounts a drive writes it its own way, so a home two or more folders below its drive (\Users\<name>)
+    // matches after any prefix, with \, / or JSON's \\ between folders. A drive written a known way goes into the swap with it.
+    const drive = /^([A-Za-z])[:-]/.exec(spelling);
+    const below = drive === null ? spelling : spelling.slice(2);
+    const body = below.split(/[\\/]+/).map(escapeRegExp).join('[\\\\/]+');
+    if (drive === null) {
+        if (spelling.length < 3)
+            return null;
+        return deep ? body : `(?<![\\p{L}\\p{N}_])${body}`;
+    }
+    if (deep)
+        return `${mountedDrive(drive[1])}?${body}`;
+    // One folder (C:\x, D:\home) is a name any path may hold, so it swaps only after its drive and as a whole name; a drive
+    // root swaps nothing.
+    return /[^\\/-]/.test(below) ? `(?<![\\p{L}\\p{N}_])${mountedDrive(drive[1])}${body}` : null;
 }
 /** One pattern for every alias of the home in every spelling, or null when none is long enough to swap safely. */
 function buildHomePattern(home, probes) {
-    const spellings = new Set();
+    const spellings = [];
     for (const alias of collectHomeAliases(home, probes)) {
-        for (const spell of HOME_SPELLINGS) {
-            const s = spell(alias);
-            if (s.length >= 3)
-                spellings.add(s);
-        }
+        // Counted on the path, since its folder-name spelling cannot tell C:\a-b from C:\a\b.
+        const deep = alias.replace(/^[A-Za-z]:/, '').split(/[\\/]+/).filter(Boolean).length >= 2;
+        for (const spell of HOME_SPELLINGS)
+            spellings.push([spell(alias), deep]);
     }
     // Longest first: where one home nests in another (a test home under the real one), swap the longer.
     const patterns = new Map();
-    for (const s of [...spellings].sort((a, b) => b.length - a.length)) {
-        const pattern = spellingPattern(s);
+    for (const [s, deep] of spellings.sort(([a], [b]) => b.length - a.length)) {
+        const pattern = spellingPattern(s, deep);
+        if (pattern === null)
+            continue;
         const key = process.platform === 'win32' ? pattern.toLowerCase() : pattern;
         if (!patterns.has(key))
             patterns.set(key, pattern);
     }
     if (patterns.size === 0)
         return null;
-    // Whole names only: "<home> now" and "<home>." swap; "<home>ty", or "web-app" for a home of /app, do not.
+    // Whole names only: "<home> now" and "<home>." swap; "<home>ty", or "web-app" for a home of /app, do not. On Windows
+    // the start is spellingPattern's call, because the path below the drive may follow anything.
+    const before = process.platform === 'win32' ? '' : '(?<![\\p{L}\\p{N}_])';
     const alternatives = [...patterns.values()].join('|');
-    return new RegExp(`(?<![\\p{L}\\p{N}_])(?:${alternatives})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
+    return new RegExp(`${before}(?:${alternatives})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
 }
 const URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi;
 function redactUrlsInString(text) {

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.52.4";
+export declare const PACKAGE_VERSION = "1.52.6";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.52.4';
+export const PACKAGE_VERSION = '1.52.6';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {
     const parse = (v) => {

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Memory for AI agents that learns what is wrong and stops repeating it. Injects context at session start and captures errors.",
-  "version": "1.52.4",
+  "version": "1.52.6",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.52.4",
+  "version": "1.52.6",
   "type": "module",
   "description": "Hippo Memory plugin for OpenClaw - biologically-inspired agent memory",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Memory for AI agents that learns what is wrong and stops repeating it. Injects context at session start and captures errors.",
-  "version": "1.52.4",
+  "version": "1.52.6",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.52.4",
+  "version": "1.52.6",
   "description": "Memory for AI agents that learns what is wrong and stops repeating it. MCP server and hooks for Claude Code, Codex and Cursor. SQLite, zero runtime deps.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",