hippo-memory 0.6.3 → 0.8.0

package/README.md

@@ -47,6 +47,7 @@ That's it. You have a memory system.
 
 - **SQLite-first storage** with markdown/JSON mirrors for humans and git
 - **Active task snapshots** for bare `continue` recovery
+- **Session event trails** for short-term continuity across stops and resumes
 - **Persistent stale-memory lifecycle** during `hippo sleep`
 - **Conflict tracking** with `hippo conflicts` and `.hippo/conflicts/` mirrors
 
@@ -126,6 +127,29 @@ hippo snapshot clear
 
 `hippo context --auto` includes the active task snapshot before long-term memories, so agents get both the immediate thread and the deeper lessons.
 
+### Session event trails
+
+Manual snapshots are useful, but real work also needs a breadcrumb trail. Hippo can now store short session events and link them to the active snapshot so context output shows the latest steps, not just the last summary.
+
+```bash
+hippo session log \
+  --id sess_20260326 \
+  --task "Ship continuity" \
+  --type progress \
+  --content "Schema migration is done, next step is CLI wiring"
+
+hippo snapshot save \
+  --task "Ship continuity" \
+  --summary "Structured session events are flowing" \
+  --next-step "Surface them in framework hooks" \
+  --session sess_20260326
+
+hippo session show --id sess_20260326
+hippo context --auto --budget 1500
+```
+
+Hippo mirrors the latest trail to `.hippo/buffer/recent-session.md` so you can inspect the short-term thread without opening SQLite.
+
 ---
 
 ## How It Works
@@ -555,11 +579,9 @@ Issues and PRs welcome. Before contributing, run `hippo status` in the repo root
 
 The interesting problems:
 - Better consolidation heuristics (what makes a good semantic memory?)
-- Embedding-based search (currently BM25 only)
-- MCP server wrapper
-- Conflict detection between semantic memories
 - Schema acceleration (fast-track memories that fit existing patterns)
 - Multi-agent shared memory with attribution
+- Benchmark eval: memory-augmented agent vs static memory vs no memory
 
 ## License
 

package/dist/cli.d.ts

@@ -11,6 +11,7 @@
  *   hippo outcome --good | --bad [--id <id>]
  *   hippo conflicts [--status <status>] [--json]
  *   hippo snapshot <save|show|clear>
+ *   hippo session <log|show>
  *   hippo forget <id>
  *   hippo inspect <id>
  *   hippo embed [--status]

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/cli.js

@@ -11,6 +11,7 @@
  *   hippo outcome --good | --bad [--id <id>]
  *   hippo conflicts [--status <status>] [--json]
  *   hippo snapshot <save|show|clear>
+ *   hippo session <log|show>
  *   hippo forget <id>
  *   hippo inspect <id>
  *   hippo embed [--status]
@@ -22,13 +23,13 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import { execSync } from 'child_process';
-import { createMemory, calculateStrength, resolveConfidence, applyOutcome, Layer, } from './memory.js';
-import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, listMemoryConflicts, } from './store.js';
-import { search, markRetrieved, estimateTokens } from './search.js';
+import { createMemory, calculateStrength, deriveHalfLife, resolveConfidence, applyOutcome, computeSchemaFit, Layer, } from './memory.js';
+import { getHippoRoot, isInitialized, initStore, writeEntry, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, } from './store.js';
+import { markRetrieved, estimateTokens, hybridSearch } from './search.js';
 import { consolidate } from './consolidate.js';
 import { isEmbeddingAvailable, embedAll, embedMemory, loadEmbeddingIndex, } from './embeddings.js';
 import { captureError, extractLessons, deduplicateLesson, runWatched, fetchGitLog, isGitRepo, } from './autolearn.js';
-import { getGlobalRoot, initGlobal, promoteToGlobal, searchBoth, syncGlobalToLocal, } from './shared.js';
+import { getGlobalRoot, initGlobal, promoteToGlobal, shareMemory, listPeers, autoShare, transferScore, searchBothHybrid, syncGlobalToLocal, } from './shared.js';
 import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, } from './importers.js';
 import { cmdCapture } from './capture.js';
 // ---------------------------------------------------------------------------
@@ -236,12 +237,16 @@ function cmdRemember(hippoRoot, text, flags) {
         confidence = 'inferred';
     if (flags['verified'])
         confidence = 'verified';
+    // Compute schema fit against existing memories
+    const existing = loadAllEntries(targetRoot);
+    const schemaFit = computeSchemaFit(text, rawTags, existing);
     const entry = createMemory(text, {
         layer: Layer.Episodic,
         tags: rawTags,
         pinned: Boolean(flags['pin']),
         source: useGlobal ? 'cli-global' : 'cli',
         confidence,
+        schema_fit: schemaFit,
     });
     writeEntry(targetRoot, entry);
     updateStats(targetRoot, { remembered: 1 });
@@ -259,7 +264,7 @@ function cmdRemember(hippoRoot, text, flags) {
         });
     }
 }
-function cmdRecall(hippoRoot, query, flags) {
+async function cmdRecall(hippoRoot, query, flags) {
     requireInit(hippoRoot);
     const budget = parseInt(String(flags['budget'] ?? '4000'), 10);
     const asJson = Boolean(flags['json']);
@@ -269,12 +274,11 @@ function cmdRecall(hippoRoot, query, flags) {
     const hasGlobal = globalEntries.length > 0;
     let results;
     if (hasGlobal) {
-        // Use searchBoth for merged results
-        const merged = searchBoth(query, hippoRoot, globalRoot, { budget });
-        results = merged;
+        // Use searchBothHybrid for merged results with embedding support
+        results = await searchBothHybrid(query, hippoRoot, globalRoot, { budget });
     }
     else {
-        results = search(query, localEntries, { budget });
+        results = await hybridSearch(query, localEntries, { budget, hippoRoot });
     }
     if (results.length === 0) {
         if (asJson) {
@@ -287,16 +291,14 @@ function cmdRecall(hippoRoot, query, flags) {
     }
     // Update retrieval metadata and persist
     const updated = markRetrieved(results.map((r) => r.entry));
+    const localIndex = loadIndex(hippoRoot);
     for (const u of updated) {
-        // Determine which store this entry belongs to
-        const localIndex = loadIndex(hippoRoot);
         const targetRoot = localIndex.entries[u.id] ? hippoRoot : (isInitialized(globalRoot) ? globalRoot : hippoRoot);
         writeEntry(targetRoot, u);
     }
     // Track last retrieval IDs for outcome command
-    const index = loadIndex(hippoRoot);
-    index.last_retrieval_ids = updated.map((u) => u.id);
-    saveIndex(hippoRoot, index);
+    localIndex.last_retrieval_ids = updated.map((u) => u.id);
+    saveIndex(hippoRoot, localIndex);
     updateStats(hippoRoot, { recalled: results.length });
     if (asJson) {
         const output = results.map((r) => ({
@@ -494,6 +496,9 @@ function printActiveTaskSnapshot(snapshot) {
     console.log(`- Status: ${snapshot.status}`);
     console.log(`- Updated: ${snapshot.updated_at}`);
     console.log(`- Source: ${snapshot.source}`);
+    if (snapshot.session_id) {
+        console.log(`- Session: ${snapshot.session_id}`);
+    }
     console.log('');
     console.log('### Summary');
     console.log(snapshot.summary);
@@ -502,6 +507,22 @@ function printActiveTaskSnapshot(snapshot) {
     console.log(snapshot.next_step);
     console.log('');
 }
+function printSessionEvents(events) {
+    if (events.length === 0) {
+        console.log('No session events found.');
+        return;
+    }
+    const latest = events[events.length - 1];
+    console.log('## Recent Session Trail\n');
+    console.log(`- Session: ${latest.session_id}`);
+    console.log(`- Task: ${latest.task ?? 'n/a'}`);
+    console.log(`- Updated: ${latest.created_at}`);
+    console.log('');
+    for (const event of events) {
+        console.log(`- [${event.created_at}] (${event.event_type}) ${event.content}`);
+    }
+    console.log('');
+}
 function cmdConflicts(hippoRoot, flags) {
     requireInit(hippoRoot);
     const conflicts = listMemoryConflicts(hippoRoot, String(flags['status'] ?? 'open'));
@@ -521,6 +542,51 @@ function cmdConflicts(hippoRoot, flags) {
         console.log('');
     }
 }
+function cmdResolve(hippoRoot, args, flags) {
+    requireInit(hippoRoot);
+    const rawId = args[0] ?? '';
+    // Accept "42" or "conflict_42"
+    const conflictId = parseInt(rawId.replace(/^conflict_/, ''), 10);
+    if (isNaN(conflictId)) {
+        console.error('Usage: hippo resolve <conflict_id> --keep <memory_id> [--forget]');
+        process.exit(1);
+    }
+    const keepId = String(flags['keep'] ?? '').trim();
+    if (!keepId) {
+        // Show the conflict details to help the user decide
+        const conflicts = listMemoryConflicts(hippoRoot, 'open');
+        const conflict = conflicts.find((c) => c.id === conflictId);
+        if (!conflict) {
+            console.error(`Conflict ${conflictId} not found or already resolved.`);
+            process.exit(1);
+        }
+        console.log(`Conflict ${conflictId}:`);
+        console.log(`  ${conflict.memory_a_id} <-> ${conflict.memory_b_id}`);
+        console.log(`  Reason: ${conflict.reason}`);
+        console.log('');
+        const entryA = readEntry(hippoRoot, conflict.memory_a_id);
+        const entryB = readEntry(hippoRoot, conflict.memory_b_id);
+        if (entryA) {
+            console.log(`  [A] ${conflict.memory_a_id}:`);
+            console.log(`      ${entryA.content.slice(0, 120)}${entryA.content.length > 120 ? '...' : ''}`);
+        }
+        if (entryB) {
+            console.log(`  [B] ${conflict.memory_b_id}:`);
+            console.log(`      ${entryB.content.slice(0, 120)}${entryB.content.length > 120 ? '...' : ''}`);
+        }
+        console.log('');
+        console.log(`Resolve with: hippo resolve ${conflictId} --keep <memory_id> [--forget]`);
+        return;
+    }
+    const forgetLoser = Boolean(flags['forget']);
+    const result = resolveConflict(hippoRoot, conflictId, keepId, forgetLoser);
+    if (!result) {
+        console.error(`Could not resolve conflict ${conflictId}. Check the ID and --keep value.`);
+        process.exit(1);
+    }
+    const action = forgetLoser ? 'deleted' : 'weakened (half-life halved)';
+    console.log(`Resolved conflict ${conflictId}: kept ${keepId}, ${action} ${result.loserId}`);
+}
 function cmdSnapshot(hippoRoot, args, flags) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? 'show';
@@ -528,8 +594,9 @@ function cmdSnapshot(hippoRoot, args, flags) {
         const task = String(flags['task'] ?? '').trim();
         const summary = String(flags['summary'] ?? '').trim();
         const nextStep = String(flags['next-step'] ?? '').trim();
+        const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim();
         if (!task || !summary || !nextStep) {
-            console.error('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>]');
+            console.error('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
             process.exit(1);
         }
         const snapshot = saveActiveTaskSnapshot(hippoRoot, {
@@ -537,10 +604,14 @@ function cmdSnapshot(hippoRoot, args, flags) {
             summary,
             next_step: nextStep,
             source: String(flags['source'] ?? 'cli'),
+            session_id: sessionId || null,
         });
         console.log(`Saved active task snapshot #${snapshot.id}`);
         console.log(`   Task: ${snapshot.task}`);
         console.log(`   Next: ${snapshot.next_step}`);
+        if (snapshot.session_id) {
+            console.log(`   Session: ${snapshot.session_id}`);
+        }
         return;
     }
     if (subcommand === 'clear') {
@@ -573,7 +644,48 @@ function cmdSnapshot(hippoRoot, args, flags) {
     console.error('Usage: hippo snapshot <save|show|clear>');
     process.exit(1);
 }
-function cmdContext(hippoRoot, args, flags) {
+function cmdSession(hippoRoot, args, flags) {
+    requireInit(hippoRoot);
+    const subcommand = args[0] ?? 'show';
+    const sessionId = String(flags['id'] ?? flags['session'] ?? '').trim();
+    const task = String(flags['task'] ?? '').trim();
+    const limit = Math.max(1, parseInt(String(flags['limit'] ?? '8'), 10) || 8);
+    if (subcommand === 'log') {
+        const eventType = String(flags['type'] ?? 'note').trim();
+        const content = String(flags['content'] ?? '').trim();
+        if (!sessionId || !content) {
+            console.error('Usage: hippo session log --id <session-id> --content <text> [--type <type>] [--task <task>] [--source <source>]');
+            process.exit(1);
+        }
+        const event = appendSessionEvent(hippoRoot, {
+            session_id: sessionId,
+            task: task || null,
+            event_type: eventType || 'note',
+            content,
+            source: String(flags['source'] ?? 'cli'),
+        });
+        console.log(`Logged session event #${event.id}`);
+        console.log(`   Session: ${event.session_id}`);
+        console.log(`   Type: ${event.event_type}`);
+        return;
+    }
+    if (subcommand === 'show') {
+        const events = listSessionEvents(hippoRoot, {
+            session_id: sessionId || undefined,
+            task: task || undefined,
+            limit,
+        });
+        if (flags['json']) {
+            console.log(JSON.stringify({ events }, null, 2));
+            return;
+        }
+        printSessionEvents(events);
+        return;
+    }
+    console.error('Usage: hippo session <log|show>');
+    process.exit(1);
+}
+async function cmdContext(hippoRoot, args, flags) {
     requireInit(hippoRoot);
     const budget = parseInt(String(flags['budget'] ?? '1500'), 10);
     // If budget is 0, skip entirely (zero token cost)
@@ -598,6 +710,9 @@ function cmdContext(hippoRoot, args, flags) {
     let selectedItems = [];
     let totalTokens = 0;
     const activeSnapshot = loadActiveTaskSnapshot(hippoRoot);
+    const recentSessionEvents = activeSnapshot?.session_id
+        ? listSessionEvents(hippoRoot, { session_id: activeSnapshot.session_id, limit: 5 })
+        : [];
     if (query === '*') {
         // No query: return strongest memories by strength, up to budget
         const now = new Date();
@@ -630,7 +745,7 @@ function cmdContext(hippoRoot, args, flags) {
     else {
         let results;
         if (hasGlobal) {
-            const merged = searchBoth(query, hippoRoot, globalRoot, { budget });
+            const merged = await searchBothHybrid(query, hippoRoot, globalRoot, { budget });
             const localIndex = loadIndex(hippoRoot);
             results = merged.map((r) => ({
                 entry: r.entry,
@@ -640,7 +755,7 @@ function cmdContext(hippoRoot, args, flags) {
             }));
         }
         else {
-            results = search(query, localEntries, { budget }).map((r) => ({
+            results = (await hybridSearch(query, localEntries, { budget, hippoRoot })).map((r) => ({
                 entry: r.entry,
                 score: r.score,
                 tokens: r.tokens,
@@ -650,7 +765,7 @@ function cmdContext(hippoRoot, args, flags) {
         selectedItems = results;
         totalTokens = results.reduce((sum, r) => sum + r.tokens, 0);
     }
-    if (selectedItems.length === 0 && !activeSnapshot)
+    if (selectedItems.length === 0 && !activeSnapshot && recentSessionEvents.length === 0)
         return;
     // Mark retrieved and persist
     const toUpdate = selectedItems.map((s) => s.entry);
@@ -675,12 +790,15 @@ function cmdContext(hippoRoot, args, flags) {
             content: r.entry.content,
             global: r.isGlobal ?? false,
         }));
-        console.log(JSON.stringify({ query, activeSnapshot, memories: output, tokens: totalTokens }));
+        console.log(JSON.stringify({ query, activeSnapshot, recentSessionEvents, memories: output, tokens: totalTokens }));
     }
     else {
         if (activeSnapshot) {
             printActiveTaskSnapshot(activeSnapshot);
         }
+        if (recentSessionEvents.length > 0) {
+            printSessionEvents(recentSessionEvents);
+        }
         printContextMarkdown(selectedItems.map((r) => ({
             entry: updatedEntries.find((u) => u.id === r.entry.id) ?? r.entry,
             score: r.score,
@@ -799,6 +917,12 @@ async function cmdWatch(command, hippoRoot) {
         process.exit(exitCode);
     }
     const entry = captureError(exitCode, stderr, command);
+    // Compute schema fit against existing memories
+    const existingWatch = loadAllEntries(hippoRoot);
+    const watchFit = computeSchemaFit(entry.content, entry.tags, existingWatch);
+    entry.schema_fit = watchFit;
+    entry.half_life_days = deriveHalfLife(7, entry);
+    entry.strength = calculateStrength(entry);
     writeEntry(hippoRoot, entry);
     updateStats(hippoRoot, { remembered: 1 });
     if (isEmbeddingAvailable()) {
@@ -829,16 +953,20 @@ function learnFromRepo(hippoRoot, repoPath, days, label) {
     }
     let added = 0;
     let skipped = 0;
+    const gitLearnTags = ['error', 'git-learned'];
+    const existingForSchema = loadAllEntries(hippoRoot);
     for (const lesson of lessons) {
         if (deduplicateLesson(hippoRoot, lesson)) {
             skipped++;
             continue;
         }
+        const schemaFitVal = computeSchemaFit(lesson, gitLearnTags, existingForSchema);
         const entry = createMemory(lesson, {
             layer: Layer.Episodic,
-            tags: ['error', 'git-learned'],
+            tags: gitLearnTags,
             source: 'git-learn',
             confidence: 'observed',
+            schema_fit: schemaFitVal,
         });
         writeEntry(hippoRoot, entry);
         updateStats(hippoRoot, { remembered: 1 });
@@ -1215,16 +1343,32 @@ Commands:
   conflicts                List detected open memory conflicts
     --status <status>      Filter by status (default: open)
     --json                 Output as JSON
+  resolve <conflict_id>    Resolve a memory conflict
+    --keep <memory_id>     Memory to keep (required)
+    --forget               Delete the losing memory (default: halve half-life)
   snapshot <sub>           Persist or inspect the current active task
     snapshot save          Save active task state
       --task <task>
       --summary <summary>
       --next-step <step>
       --source <source>    Optional source label
+      --session <id>       Link snapshot to a session trail
     snapshot show          Show the active task snapshot
       --json               Output as JSON
     snapshot clear         Clear the active task snapshot
       --status <status>    Mark final status (default: cleared)
+  session <sub>            Append or inspect short-term session history
+    session log            Append a structured session event
+      --id <session-id>
+      --content <text>
+      --type <type>        Event type (default: note)
+      --task <task>        Optional task label
+      --source <source>    Optional source label
+    session show           Show recent events for a session or task
+      --id <session-id>
+      --task <task>
+      --limit <n>          Event limit (default: 8)
+      --json               Output as JSON
   forget <id>              Force remove a memory
   inspect <id>             Show full memory detail
   embed                    Embed all memories for semantic search
@@ -1235,6 +1379,12 @@ Commands:
     --days <n>             Scan this many days back (default: 7)
     --repos <paths>        Comma-separated repo paths to scan
   promote <id>             Copy a local memory to the global store
+  share <id>               Share a memory with attribution + transfer scoring
+    --force                Share even if transfer score is low
+    --auto                 Auto-share all high-transfer-score memories
+    --dry-run              Preview what would be shared
+    --min-score <n>        Minimum transfer score (default: 0.6)
+  peers                    List projects contributing to global store
   sync                     Pull global memories into local project
   import                   Import memories from other AI tools
     --chatgpt <path>       Import from ChatGPT memory export (JSON or txt)
@@ -1263,7 +1413,8 @@ Examples:
   hippo recall "data pipeline issues" --budget 2000
   hippo context --auto --budget 1500
   hippo conflicts
-  hippo snapshot save --task "Ship feature" --summary "Tests are green" --next-step "Open the PR"
+  hippo session log --id sess_123 --task "Ship feature" --type progress --content "Build is green, next step is docs"
+  hippo snapshot save --task "Ship feature" --summary "Tests are green" --next-step "Open the PR" --session sess_123
   hippo embed --status
   hippo watch "npm run build"
   hippo learn --git --days 30
@@ -1300,7 +1451,7 @@ async function main() {
                 console.error('Please provide a search query.');
                 process.exit(1);
             }
-            cmdRecall(hippoRoot, query, flags);
+            await cmdRecall(hippoRoot, query, flags);
             break;
         }
         case 'sleep':
@@ -1315,9 +1466,15 @@ async function main() {
         case 'conflicts':
             cmdConflicts(hippoRoot, flags);
             break;
+        case 'resolve':
+            cmdResolve(hippoRoot, args, flags);
+            break;
         case 'snapshot':
             cmdSnapshot(hippoRoot, args, flags);
             break;
+        case 'session':
+            cmdSession(hippoRoot, args, flags);
+            break;
         case 'forget': {
             const id = args[0];
             if (!id) {
@@ -1337,7 +1494,7 @@ async function main() {
             break;
         }
         case 'context':
-            cmdContext(hippoRoot, args, flags);
+            await cmdContext(hippoRoot, args, flags);
             break;
         case 'hook':
             cmdHook(args, flags);
@@ -1365,6 +1522,71 @@ async function main() {
         case 'sync':
             cmdSync(hippoRoot);
             break;
+        case 'share': {
+            const shareId = args[0];
+            if (shareId === '--auto' || flags['auto']) {
+                // Auto-share mode
+                requireInit(hippoRoot);
+                const minScore = parseFloat(String(flags['min-score'] ?? '0.6'));
+                const dryRun = Boolean(flags['dry-run']);
+                const results = autoShare(hippoRoot, { minScore, dryRun });
+                if (results.length === 0) {
+                    console.log('No memories meet the sharing threshold.');
+                }
+                else if (dryRun) {
+                    console.log(`Would share ${results.length} memories:\n`);
+                    for (const e of results) {
+                        const score = transferScore(e);
+                        console.log(`  ${e.id} (transfer=${fmt(score)}) ${e.content.slice(0, 80)}...`);
+                    }
+                }
+                else {
+                    console.log(`Shared ${results.length} memories to global store.`);
+                    for (const e of results) {
+                        console.log(`  ${e.id} <- ${e.source}`);
+                    }
+                }
+            }
+            else if (shareId) {
+                requireInit(hippoRoot);
+                const force = Boolean(flags['force']);
+                const result = shareMemory(hippoRoot, shareId, { force });
+                if (result) {
+                    console.log(`Shared [${result.id}] to global store.`);
+                    console.log(`  Source: ${result.source}`);
+                }
+                else {
+                    const entry = readEntry(hippoRoot, shareId);
+                    if (entry) {
+                        const score = transferScore(entry);
+                        console.log(`Transfer score too low (${fmt(score)}). This memory looks project-specific.`);
+                        console.log('Use --force to share anyway.');
+                    }
+                    else {
+                        console.error(`Memory not found: ${shareId}`);
+                        process.exit(1);
+                    }
+                }
+            }
+            else {
+                console.error('Usage: hippo share <memory_id> [--force] or hippo share --auto [--dry-run]');
+                process.exit(1);
+            }
+            break;
+        }
+        case 'peers': {
+            const peers = listPeers();
+            if (peers.length === 0) {
+                console.log('No peers found. Share memories with: hippo share <id>');
+            }
+            else {
+                console.log(`${peers.length} project${peers.length === 1 ? '' : 's'} contributing to global store:\n`);
+                for (const p of peers) {
+                    console.log(`  ${p.project.padEnd(25)} ${String(p.count).padStart(4)} memories  (latest: ${p.latest.slice(0, 10)})`);
+                }
+            }
+            break;
+        }
         case 'import':
             cmdImport(hippoRoot, args, flags);
             break;