hippo-memory 1.52.7 → 1.52.8

package/README.md

@@ -87,7 +87,7 @@ hippo init --scan ~
 After setup, `hippo sleep` runs at session end (via auto-installed agent hooks) and does five things:
 
 1. **Learns** from today's git commits
-2. **Imports** new entries from Claude Code MEMORY.md files
+2. **Imports** new entries from the project's Claude Code auto memory
 3. **Consolidates** memories (decay, merge, prune)
 4. **Deduplicates** near-identical memories, keeping the stronger copy
 5. **Shares** high-value lessons to a global store so they surface in every project

package/dist/api.d.ts

@@ -95,6 +95,7 @@ export { classifyOriginProject } from './project-identity.js';
  * flagged rows with no project origin never ambient-inject.
  */
 export declare function ambientSecretAdmit(e: MemoryEntry, currentProjectName: string): boolean;
+export declare function oneCopyPerMemory(local: readonly MemoryEntry[], global: readonly MemoryEntry[], now: Date): [MemoryEntry[], MemoryEntry[]];
 export interface RememberOpts {
     content: string;
     kind?: MemoryKind;

package/dist/api.js

@@ -142,6 +142,26 @@ function loadAmbientEntries(hippoRoot, tenantId, pinnedOnly, includeRecent, admi
     const admitAmbient = (e) => admit(e) && (e.pinned || isContentWorthStoring(e.content));
     return loadAmbientCandidates(hippoRoot, tenantId, includeRecent, admitAmbient, recall);
 }
+// Share and promote copy a memory to the global store under a new id, so equal content is the only link.
+// A pinned copy wins, then the stronger one after the ranking's own global discount; a tie keeps the local copy.
+export function oneCopyPerMemory(local, global, now) {
+    const score = (e, isGlobal) => calculateStrength(e, now) * (isGlobal ? 1 / 1.2 : 1);
+    const best = new Map();
+    const offer = (entry, isGlobal) => {
+        const held = best.get(entry.content);
+        const wins = !held || (held.entry.pinned !== entry.pinned
+            ? entry.pinned
+            : score(entry, isGlobal) > score(held.entry, held.isGlobal));
+        if (wins)
+            best.set(entry.content, { entry, isGlobal });
+    };
+    for (const e of local)
+        offer(e, false);
+    for (const e of global)
+        offer(e, true);
+    const kept = new Set([...best.values()].map((b) => b.entry));
+    return [local.filter((e) => kept.has(e)), global.filter((e) => kept.has(e))];
+}
 export function remember(ctx, opts) {
     const detection = opts.untrusted ? detectInstruction(opts.content) : { flagged: false, reason: null };
     const requestedScope = opts.scope ?? null;
@@ -1620,13 +1640,14 @@ export async function getContext(ctx, opts = {}) {
         // Effective budget: explicit opts.budget wins over config.
         const effBudget = opts.budget !== undefined ? budget : pinnedCfg.pinnedInject.budget;
         const nowP = evalNow(); // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
+        const [localPool, globalPool] = oneCopyPerMemory(localEntries, globalEntries, nowP);
         const selectedIds = new Set();
         let usedP = 0;
         // Pinned entries are explicit user intent, the recent-N list an automatic
         // backfill. Both loops share ONE budget and the recent loop runs first, so
         // pins are ranked here and reserve their share before it can spend.
-        const pinnedLocal = localEntries.filter((e) => e.pinned);
-        const pinnedGlobal = globalEntries.filter((e) => e.pinned);
+        const pinnedLocal = localPool.filter((e) => e.pinned);
+        const pinnedGlobal = globalPool.filter((e) => e.pinned);
         const rankedPinned = [
             ...pinnedLocal.map((e) => ({ entry: e, isGlobal: false })),
             ...pinnedGlobal.map((e) => ({ entry: e, isGlobal: true })),
@@ -1683,19 +1704,21 @@ export async function getContext(ctx, opts = {}) {
             const p = promptTokens(opts.prompt ?? '');
             if (p.size > 0) {
                 // Candidates came off the ambient load's own connection (recallRequest above), not a fresh open.
-                const localCandidates = localLoad.recall ?? [];
-                const globalCandidates = globalLoad.recall ?? [];
+                // A candidate carrying a pin's text would inject that memory a second time.
+                const pinnedText = new Set(rankedPinned.map((r) => r.entry.content));
+                const eligible = (e) => admit(e) && !e.pinned && isContentWorthStoring(e.content) && !pinnedText.has(e.content);
+                const [localCandidates, globalCandidates] = oneCopyPerMemory((localLoad.recall ?? []).filter(eligible), (globalLoad.recall ?? []).filter(eligible), nowP);
                 const seenCandidateIds = new Set();
                 const candidateItems = [];
                 // Local wins the id collision (a global row synced into the local store).
                 for (const e of localCandidates) {
-                    if (!admit(e) || e.pinned || !isContentWorthStoring(e.content) || seenCandidateIds.has(e.id))
+                    if (seenCandidateIds.has(e.id))
                         continue;
                     seenCandidateIds.add(e.id);
                     candidateItems.push({ id: e.id, tokens: contentTokens(e.content), entry: e, isGlobal: false });
                 }
                 for (const e of globalCandidates) {
-                    if (!admit(e) || e.pinned || !isContentWorthStoring(e.content) || seenCandidateIds.has(e.id))
+                    if (seenCandidateIds.has(e.id))
                         continue;
                     seenCandidateIds.add(e.id);
                     candidateItems.push({ id: e.id, tokens: contentTokens(e.content), entry: e, isGlobal: true });
@@ -1715,8 +1738,8 @@ export async function getContext(ctx, opts = {}) {
         }
         else if (includeRecent > 0) {
             const recent = [
-                ...localEntries.map((entry) => ({ entry, isGlobal: false })),
-                ...globalEntries.map((entry) => ({ entry, isGlobal: true })),
+                ...localPool.map((entry) => ({ entry, isGlobal: false })),
+                ...globalPool.map((entry) => ({ entry, isGlobal: true })),
             ]
                 // T2 (src/compare.ts) note: this already carries an explicit
                 // per-instance tiebreak (created desc -> id localeCompare) and is
@@ -1784,7 +1807,8 @@ export async function getContext(ctx, opts = {}) {
     else if (query === '*') {
         // No query: return strongest memories by strength, up to budget.
         const now = evalNow(); // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
-        const localRanked = localEntries
+        const [localPool, globalPool] = oneCopyPerMemory(localEntries, globalEntries, now);
+        const localRanked = localPool
             .map((e) => ({
             entry: e,
             score: calculateStrength(e, now),
@@ -1792,7 +1816,7 @@ export async function getContext(ctx, opts = {}) {
             isGlobal: false,
         }))
             .sort(compareScoredResults);
-        const globalRanked = globalEntries
+        const globalRanked = globalPool
             .map((e) => ({
             entry: e,
             score: calculateStrength(e, now) * (1 / 1.2),

package/dist/autolearn.js

@@ -120,7 +120,7 @@ export function deduplicateLesson(hippoRootOrEntries, lesson, threshold = 0.7, t
 export function runWatched(command) {
     return new Promise((resolve) => {
         // Use shell: true so the command string is handled by the shell as-is
-        const child = spawn(command, { shell: true, stdio: ['inherit', 'inherit', 'pipe'] });
+        const child = spawn(command, { shell: true, stdio: ['inherit', 'inherit', 'pipe'], windowsHide: true });
         const stderrChunks = [];
         child.stderr.on('data', (chunk) => {
             stderrChunks.push(chunk);
@@ -148,6 +148,7 @@ export function isGitRepo(cwd) {
             cwd,
             timeout: 10000,
             stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
         });
         return raw.trim() === 'true';
     }
@@ -163,7 +164,7 @@ export function fetchGitLog(cwd, days) {
     try {
         const raw = execFileSync('git', [
             'log', `--since=${days} days ago`, '--pretty=format:%s',
-        ], { encoding: 'utf8', cwd, timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] });
+        ], { encoding: 'utf8', cwd, timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
         return raw;
     }
     catch {

package/dist/capture.d.ts

@@ -8,6 +8,7 @@
  *   - Errors / gotchas ("error:", "bug:", "gotcha:", "watch out")
  *   - Preferences ("prefer", "use X instead of Y", "don't use")
  */
+import { type TaskSnapshot } from './store.js';
 export interface ExtractedItem {
     content: string;
     category: string;
@@ -116,6 +117,8 @@ export declare function preCompactMessage(report: Pick<PreCompactReport, 'snapsh
  * pre-compact log, so both hooks find it from the same `--log-file`.
  */
 export declare function preCompactReportPath(logFile: string): string;
+/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
+export declare function transcriptWorkingState(transcriptPath: string, log: (message: string) => void): Pick<TaskSnapshot, 'task' | 'summary' | 'next_step'> | null;
 export interface PreCompactOptions {
     stdinText?: string;
     stdinTimedOut?: boolean;

package/dist/capture.js

@@ -18,7 +18,7 @@ import { embedMemory } from './embeddings.js';
 import { isEmbeddingConfigured } from './embedding-provider.js';
 import { resolveTenantId } from './tenant.js';
 import { defaultPreCompactLogPath } from './hooks.js';
-import { redactSecrets } from './secret-detect.js';
+import { redactSecretsStrict } from './secret-detect.js';
 import { RejectedValueError, checkRejectionGuard } from './rejection.js';
 import { openHippoDb, closeHippoDb } from './db.js';
 import { loadConfig } from './config.js';
@@ -1080,6 +1080,46 @@ export function preCompactMessage(report) {
 export function preCompactReportPath(logFile) {
     return path.join(path.dirname(logFile), 'pre-compact-last.json');
 }
+/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
+export function transcriptWorkingState(transcriptPath, log) {
+    let tail;
+    try {
+        // CX7 (codex round 2): a final record bigger than the window leaves an empty tail, as when a huge tool_result
+        // triggered compaction, so grow the window a bounded number of times until one complete line survives.
+        tail = readTranscriptTail(transcriptPath, PRE_COMPACT_TAIL_BYTES);
+        let prevCap = PRE_COMPACT_TAIL_BYTES;
+        for (const grownCap of [PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
+            if (tail.trim() !== '')
+                break;
+            if (fs.statSync(transcriptPath).size <= prevCap)
+                break; // already read the whole file
+            log(`tail window grown to ${grownCap} bytes (oversized final record)`);
+            tail = readTranscriptTail(transcriptPath, grownCap);
+            prevCap = grownCap;
+        }
+    }
+    catch (err) {
+        log(`skip: could not read transcript tail: ${errorMessage(err)}`);
+        return null;
+    }
+    const rawSummary = summariseTranscript(tail);
+    const rawTask = lastPlainUserMessage(tail);
+    const rawNextStep = lastAssistantTextBlock(tail);
+    if (!rawTask.trim() && !rawSummary.trim() && !rawNextStep.trim()) {
+        log('skip: empty summary');
+        return null;
+    }
+    // X9: these fields skip the capture content gate and reach a prompt, so the strict scrub runs. The caps protect the
+    // re-injection token budget and never split a surrogate pair (X2); `hippo snapshot save` stays uncapped.
+    const task = redactSecretsStrict(rawTask);
+    const summary = redactSecretsStrict(rawSummary);
+    const nextStep = redactSecretsStrict(rawNextStep);
+    return {
+        task: task.trim() ? truncateCodePointSafe(task, PRE_COMPACT_TASK_CAP) : '',
+        summary: summary.trim() ? truncateKeepNewest(summary, PRE_COMPACT_SUMMARY_CAP) : '',
+        next_step: nextStep.trim() ? truncateCodePointSafe(nextStep, PRE_COMPACT_NEXT_STEP_CAP) : '',
+    };
+}
 /** Runs the PreCompact producer: saves a working-state snapshot into `report`. Never extracts memories; SessionEnd capture owns that. */
 function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     // X3: the PreCompact hook fires in every Claude Code project, including
@@ -1160,40 +1200,10 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         appendPreCompactLog(logFile, 'skip: no transcript resolved');
         return;
     }
-    let tail;
-    try {
-        // CX7 (codex round 2): a final JSONL record larger than the window
-        // swallows the whole tail — the seek lands inside it and alignment
-        // drops everything up to its terminator, which is exactly the shape of
-        // a huge tool_result that itself triggered compaction. Grow the window
-        // a bounded number of times until at least one complete line survives.
-        tail = readTranscriptTail(transcriptPath, PRE_COMPACT_TAIL_BYTES);
-        let prevCap = PRE_COMPACT_TAIL_BYTES;
-        for (const grownCap of [PRE_COMPACT_TAIL_BYTES * 4, PRE_COMPACT_TAIL_BYTES * 16]) {
-            if (tail.trim() !== '')
-                break;
-            if (fs.statSync(transcriptPath).size <= prevCap)
-                break; // already read the whole file
-            appendPreCompactLog(logFile, `tail window grown to ${grownCap} bytes (oversized final record)`);
-            tail = readTranscriptTail(transcriptPath, grownCap);
-            prevCap = grownCap;
-        }
-    }
-    catch (err) {
-        appendPreCompactLog(logFile, `skip: could not read transcript tail: ${errorMessage(err)}`);
-        return;
-    }
-    const summaryFull = summariseTranscript(tail);
-    // Snapshot fields must never carry raw secrets, same rule X9 applies below to task/next_step.
-    const scrubbedSummary = redactSecrets(summaryFull);
-    const rawTask = lastPlainUserMessage(tail);
-    const rawNextStep = lastAssistantTextBlock(tail);
-    // Full skip only when every derived field is empty: never clobber a
-    // user-authored active snapshot with junk.
-    if (!rawTask.trim() && !summaryFull.trim() && !rawNextStep.trim()) {
-        appendPreCompactLog(logFile, 'skip: empty summary');
+    // Nothing derivable skips the write, so a user-authored active snapshot is never clobbered with junk.
+    const derived = transcriptWorkingState(transcriptPath, (message) => appendPreCompactLog(logFile, message));
+    if (!derived)
         return;
-    }
     const tenantId = resolveTenantId({});
     // Per-field merge (X1): a tool-heavy tail whose only user turns are
     // tool_result arrays derives an empty task even though the summary is
@@ -1207,15 +1217,6 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
     catch {
         // No existing snapshot to merge against — proceed with derived-only.
     }
-    // X9: scrub secret-shaped substrings out of freshly-derived text before it
-    // is capped/stored. These fields bypass the normal capture content gate
-    // (they're not extracted items), so this producer is the only place that
-    // ever sees them before they land in task_snapshots. Carried-over
-    // existing field values are NOT re-scrubbed here — they already passed
-    // through this same gate (or were set via `hippo snapshot save`, which is
-    // deliberately untouched, same as the caps below).
-    const scrubbedTask = redactSecrets(rawTask);
-    const scrubbedNextStep = redactSecrets(rawNextStep);
     // CX6 (codex round 2): field fallback must never move content across
     // sessions — session A's task carried into a snapshot saved under session
     // B's id would pass compact-resume's session gate wearing the wrong
@@ -1225,19 +1226,10 @@ function runPreCompact(hippoRoot, stdinText, stdinTimedOut, logFile, report) {
         (existing.session_id === null || sessionId === null || existing.session_id === sessionId)
         ? existing
         : null;
-    // Field caps are enforced HERE ONLY — saveActiveTaskSnapshot and the
-    // `hippo snapshot save` CLI path stay uncapped (AGENTS.md public-API
-    // preservation). Caps protect the re-injection token budget. Code-point
-    // safe (X2): never split a surrogate pair at the cut.
-    const task = scrubbedTask.trim()
-        ? truncateCodePointSafe(scrubbedTask, PRE_COMPACT_TASK_CAP)
-        : (fallback?.task ?? '');
-    const summary = scrubbedSummary.trim()
-        ? truncateKeepNewest(scrubbedSummary, PRE_COMPACT_SUMMARY_CAP)
-        : (fallback?.summary ?? '');
-    const nextStep = scrubbedNextStep.trim()
-        ? truncateCodePointSafe(scrubbedNextStep, PRE_COMPACT_NEXT_STEP_CAP)
-        : (fallback?.next_step ?? '');
+    // Carried-over fields are not re-capped, as `hippo snapshot save` stays uncapped; saveActiveTaskSnapshot scrubs every field.
+    const task = derived.task || (fallback?.task ?? '');
+    const summary = derived.summary || (fallback?.summary ?? '');
+    const nextStep = derived.next_step || (fallback?.next_step ?? '');
     // All-empty fields (cross-session tail with nothing derivable) skip the
     // write so a foreign session's junk never displaces the owning snapshot.
     if (!task && !summary && !nextStep) {

package/dist/churn-git.js

@@ -10,7 +10,7 @@ export class GitReadError extends Error {
 }
 function runGit(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
     }
     catch (err) {
         throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -19,7 +19,7 @@ function runGit(args, repoRoot) {
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
 function runGitGrepOrEmpty(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER });
+        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
     }
     catch (err) {
         // SAFETY: execFileSync attaches `status` to the thrown Error on a non-zero child exit.

package/dist/cli.d.ts

@@ -43,10 +43,7 @@ export declare function parseArgs(argv: string[]): {
     args: string[];
     flags: Record<string, string | boolean | string[]>;
 };
-/**
- * Scan for Claude Code MEMORY.md files and import new entries into hippo.
- * Looks in ~/.claude/projects/<project>/memory/ for .md files with YAML frontmatter.
- */
+/** Import new entries from the Claude Code auto memory of the store's project, the frontmatter .md files in ~/.claude/projects/<project>/memory/. */
 export declare function learnFromMemoryMd(hippoRoot: string, homeDir?: string): number;
 /**
  * Render an api.sleep result as console output, byte-identical to the

package/dist/cli.js

@@ -37,7 +37,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 { execFileSync, execSync, spawn, spawnSync } from 'child_process';
 import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, isCodexWrapperInstalled, repairCodexWrapperIfInstalled, uninstallCodexWrapper, resolveCodexSessionTranscript, resolveCodexWrapperPaths, installOpencodePlugin, uninstallOpencodePlugin, resolveOpencodePluginPath, } from './hooks.js';
 import { createMemory, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, confidenceFacets, confidenceLabel, computeSchemaFit, Layer, } from './memory.js';
 import { detectSecret } from './secret-detect.js';
@@ -69,13 +69,13 @@ import { pushGoal, getActiveGoals, completeGoal, suspendGoal, resumeGoal, applyG
 import { rowToGoal } from './goals.js';
 import { captureError, extractLessons, partitionLessons, deduplicateLesson, runWatched, fetchGitLog, isGitRepo, } from './autolearn.js';
 import { extractInvalidationTarget, invalidateMatching, detectChurnStale } from './invalidation.js';
-import { resolveProjectIdentity } from './project-identity.js';
+import { realpathOrResolve, resolveProjectIdentity } from './project-identity.js';
 import { extractPathTags } from './path-context.js';
 import { detectScope } from './scope.js';
 import { getGlobalRoot, initGlobal, 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, importVault, } from './importers.js';
-import { cmdCapture, cmdPreCompact, postCompactMessage, resolveLastSessionTranscript, truncateCodePointSafe, sanitizeLogMessage } from './capture.js';
+import { cmdCapture, cmdPreCompact, postCompactMessage, resolveLastSessionTranscript, truncateCodePointSafe, sanitizeLogMessage, transcriptWorkingState } from './capture.js';
 import { readStdinBounded } from './stdin.js';
 import { auditMemories, appendAuditEvent, } from './audit.js';
 import { listApiKeys, revokeApiKey } from './auth.js';
@@ -203,7 +203,7 @@ function requireInit(hippoRoot) {
 }
 /** FE2: run detectChurnStale against every store this repo's memories can live in. */
 function runChurnStaleForRepo(hippoRoot, dryRun) {
-    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8' }).trim();
+    const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: process.cwd(), encoding: 'utf8', windowsHide: true }).trim();
     const projectName = resolveProjectIdentity(process.cwd()).name;
     const globalRoot = getGlobalRoot();
     const roots = globalRoot !== hippoRoot && isInitialized(globalRoot) ? [hippoRoot, globalRoot] : [hippoRoot];
@@ -547,10 +547,9 @@ function cmdInit(hippoRoot, flags) {
                 console.log(`   No matching commits found in git history.`);
             }
         }
-        // Also import from Claude Code / agent MEMORY.md files
         const memImported = learnFromMemoryMd(hippoRoot);
         if (memImported > 0) {
-            console.log(`   Imported ${memImported} memories from agent MEMORY.md files.`);
+            console.log(`   Imported ${memImported} memories from this project's Claude Code auto memory.`);
         }
     }
 }
@@ -711,7 +710,7 @@ function setupDailySchedule(globalRoot) {
     if (isWindows) {
         // Check if task already exists
         try {
-            const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8' });
+            const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8', windowsHide: true });
             if (existing.includes(taskName)) {
                 return; // already scheduled
             }
@@ -720,7 +719,7 @@ function setupDailySchedule(globalRoot) {
             // Task doesn't exist, create it
         }
         try {
-            execSync(`schtasks /create /tn "${taskName}" /tr "cmd /c ${cmd.replace(/"/g, '""')}" /sc daily /st 06:15 /f`, { stdio: 'pipe' });
+            execSync(`schtasks /create /tn "${taskName}" /tr "cmd /c ${cmd.replace(/"/g, '""')}" /sc daily /st 06:15 /f`, { stdio: 'pipe', windowsHide: true });
             console.log(`   Scheduled machine-level daily runner (6:15am) via Task Scheduler: ${taskName}`);
         }
         catch {
@@ -733,13 +732,13 @@ function setupDailySchedule(globalRoot) {
         // Unix: check crontab for existing entry
         const marker = `# hippo:${taskName}`;
         try {
-            const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8' });
+            const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', windowsHide: true });
             if (existing.includes(marker)) {
                 return; // already scheduled
             }
             const cronLine = `15 6 * * * ${cmd} ${marker}`;
             const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
-            execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'] });
+            execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
             console.log(`   Scheduled machine-level daily runner (6:15am) via crontab`);
         }
         catch {
@@ -1119,7 +1118,8 @@ async function cmdRecall(hippoRoot, query, flags) {
         });
     }
     else if (useMultihop) {
-        const allEntries = [...localEntries, ...globalEntries];
+        // Unlike searchBothHybrid below, multihop ranks one pooled list, so a shared memory's two copies both compete.
+        const allEntries = api.oneCopyPerMemory(localEntries, globalEntries, evalNow()).flat();
         results = multihopSearch(query, allEntries, {
             budget,
             hippoRoot,
@@ -2645,25 +2645,43 @@ async function cmdRefine(hippoRoot, flags) {
         }
     }
 }
-/**
- * Scan for Claude Code MEMORY.md files and import new entries into hippo.
- * Looks in ~/.claude/projects/<project>/memory/ for .md files with YAML frontmatter.
- */
+/** Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself outside a repository. */
+function claudeMemoryFolderNames(projectRoot) {
+    const roots = [projectRoot, realpathOrResolve(projectRoot)];
+    const git = spawnSync('git', ['rev-parse', '--path-format=absolute', '--show-toplevel', '--absolute-git-dir', '--git-common-dir'], { cwd: projectRoot, encoding: 'utf8', timeout: 10000, windowsHide: true });
+    if (git.status === 0) {
+        const [top, gitDir, common] = git.stdout.trim().split(/\r?\n/);
+        roots.push(claudeCheckoutRoot(top, gitDir, common));
+    }
+    return new Set(roots.map((root) => (process.platform === 'win32' ? claudeFolderName(root).toLowerCase() : claudeFolderName(root))));
+}
+/** Claude Code's rule: a linked worktree shares its main checkout's folder, or the git folder's when that sits outside a checkout (a bare repository, or --separate-git-dir); any other checkout, a submodule included, keeps its own. */
+function claudeCheckoutRoot(top, gitDir, common) {
+    if (gitDir === common)
+        return top;
+    if (path.basename(common) === '.git')
+        return path.dirname(common);
+    return fs.existsSync(path.join(common, '.git')) ? top : common;
+}
+/** Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a base-36 hash of the whole path. */
+function claudeFolderName(root) {
+    const full = path.resolve(root);
+    const name = full.replace(/[^a-zA-Z0-9]/g, '-');
+    if (name.length <= 200)
+        return name;
+    let hash = 0;
+    for (let i = 0; i < full.length; i++)
+        hash = ((hash << 5) - hash + full.charCodeAt(i)) | 0;
+    return `${name.slice(0, 200)}-${Math.abs(hash).toString(36)}`;
+}
+/** Import new entries from the Claude Code auto memory of the store's project, the frontmatter .md files in ~/.claude/projects/<project>/memory/. */
 export function learnFromMemoryMd(hippoRoot, homeDir = os.homedir()) {
-    const home = homeDir;
-    const memoryDirs = [];
-    // Claude Code project memories
-    const claudeProjectsDir = path.join(home, '.claude', 'projects');
-    if (fs.existsSync(claudeProjectsDir)) {
-        try {
-            for (const project of fs.readdirSync(claudeProjectsDir)) {
-                const memDir = path.join(claudeProjectsDir, project, 'memory');
-                if (fs.existsSync(memDir))
-                    memoryDirs.push(memDir);
-            }
-        }
-        catch { /* permission denied */ }
-    }
+    // Only this project's folder, because every entry written here counts as this project's memory.
+    // SHORTCUT: an autoMemoryDirectory or CLAUDE_CODE_PROJECT_DIR_NAME setting imports nothing; read Claude's settings if users ask.
+    const claudeProjectsDir = path.join(homeDir, '.claude', 'projects');
+    const memoryDirs = [...claudeMemoryFolderNames(path.dirname(hippoRoot))]
+        .map((folder) => path.join(claudeProjectsDir, folder, 'memory'))
+        .filter((memDir) => fs.existsSync(memDir));
     if (memoryDirs.length === 0)
         return 0;
     const existing = loadAllEntries(hippoRoot, resolveTenantId({}));
@@ -2895,10 +2913,10 @@ export function renderSleepResult(result) {
 }
 async function cmdSleepCore(hippoRoot, flags) {
     requireInit(hippoRoot);
-    // Phase 1: Auto-learn from git + MEMORY.md (CLI-only, uses process.cwd() / os.homedir()).
+    // Phase 1: Auto-learn from git + Claude Code auto memory (CLI-only, uses process.cwd() / os.homedir()).
     // Stays in cli.ts; api.sleep covers Phase 2-6 only.
     if (!flags['no-learn'] && flags['dry-run']) {
-        console.log('Dry run: skipped learning from git commits and MEMORY.md files.');
+        console.log("Dry run: skipped learning from git commits and this project's Claude Code auto memory.");
     }
     else if (!flags['no-learn']) {
         const config = loadConfig(hippoRoot);
@@ -2916,10 +2934,9 @@ async function cmdSleepCore(hippoRoot, flags) {
                     console.error(`Churn-staleness check failed for ${root}: ${result.error}`);
             }
         }
-        // Also learn from Claude Code MEMORY.md files
         const memImported = learnFromMemoryMd(hippoRoot);
         if (memImported > 0)
-            console.log(`Imported ${memImported} memories from Claude Code MEMORY.md files.`);
+            console.log(`Imported ${memImported} memories from this project's Claude Code auto memory.`);
     }
     // Phase 2-6: Pure-storage pipeline (consolidate + dedup + audit + share + ambient).
     const ctx = {
@@ -2933,12 +2950,8 @@ async function cmdSleepCore(hippoRoot, flags) {
     });
     renderSleepResult(result);
 }
-/**
- * Print the contents of the SessionEnd sleep log to stdout, then clear it.
- * Called from SessionStart hooks so the user sees the previous session's
- * consolidation output (SessionEnd hook output is invisible because the TUI
- * is tearing down when it runs).
- */
+/** Prints the SessionEnd sleep log, then clears it. Stderr, because Claude Code adds
+ *  SessionStart stdout to the model's context and this log is for the user. */
 function cmdLastSleep(flags) {
     const logPath = typeof flags['path'] === 'string'
         ? flags['path']
@@ -2953,11 +2966,11 @@ function cmdLastSleep(flags) {
         return;
     }
     if (content.trim().length > 0) {
-        console.log('=== Previous session hippo consolidation ===');
-        process.stdout.write(content);
+        console.error('=== Previous session hippo consolidation ===');
+        process.stderr.write(content);
         if (!content.endsWith('\n'))
-            console.log();
-        console.log('===========================================');
+            console.error();
+        console.error('===========================================');
     }
     if (!flags['keep']) {
         try {
@@ -3134,7 +3147,7 @@ function collectHandoffEvidence(cwd, testStatus) {
     let gitRef = null;
     try {
         gitRef = execFileSync('git', ['rev-parse', 'HEAD'], {
-            cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+            cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true,
         }).trim() || null;
     }
     catch {
@@ -3143,7 +3156,7 @@ function collectHandoffEvidence(cwd, testStatus) {
     let dirtyTree = null;
     try {
         const status = execFileSync('git', ['status', '--porcelain'], {
-            cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'],
+            cwd, encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true,
         });
         dirtyTree = status.trim().length > 0;
     }
@@ -3160,9 +3173,9 @@ async function cmdSessionEndWorker(hippoRoot, flags) {
         // sleep errors are already tee'd to the log file via cmdSleep's
         // `[hippo] sleep failed: ...` line. Continue to capture regardless.
     }
+    const transcriptPath = typeof flags['transcript'] === 'string' ? flags['transcript'] : undefined;
     try {
         const logFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : undefined;
-        const transcriptPath = typeof flags['transcript'] === 'string' ? flags['transcript'] : undefined;
         // With no stdin of its own, capture would read this as a manual run and scan every project.
         if (!transcriptPath) {
             appendSessionEndCloseLog(logFile ?? null, 'skip capture: no transcript for this session');
@@ -3195,14 +3208,19 @@ async function cmdSessionEndWorker(hippoRoot, flags) {
     // snapshot writeSessionEndHandoff reads is still active.
     if (closeSessionId) {
         try {
-            const activeForHandoff = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
-            if (!activeForHandoff || activeForHandoff.session_id !== closeSessionId) {
-                appendSessionEndCloseLog(closeLogFile, 'skip: no active snapshot for session');
+            const tenantId = resolveTenantId({});
+            const ownSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId)?.session_id === closeSessionId;
+            // A never-compacted session has no snapshot; read even when it has one, as another session's PreCompact can take the slot before the write.
+            const derived = transcriptPath
+                ? transcriptWorkingState(transcriptPath, (message) => appendSessionEndCloseLog(closeLogFile, message))
+                : null;
+            if (!ownSnapshot && !derived) {
+                appendSessionEndCloseLog(closeLogFile, 'skip: no snapshot or transcript for session');
             }
             else {
                 const evidence = collectHandoffEvidence(process.cwd(), 'unknown');
-                const handoff = writeSessionEndHandoff(hippoRoot, resolveTenantId({}), closeSessionId, evidence);
-                appendSessionEndCloseLog(closeLogFile, handoff ? `wrote handoff for session ${closeSessionId}` : 'skip: handoff newer than snapshot');
+                const handoff = writeSessionEndHandoff(hippoRoot, tenantId, closeSessionId, evidence, derived);
+                appendSessionEndCloseLog(closeLogFile, handoff ? `wrote handoff for session ${closeSessionId}` : `skip: kept the existing handoff for session ${closeSessionId}`);
             }
         }
         catch (err) {
@@ -6127,7 +6145,7 @@ function cmdGraph(hippoRoot, args, flags) {
                     : process.platform === 'darwin'
                         ? ['open', [out]]
                         : ['xdg-open', [out]];
-                const child = spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore' });
+                const child = spawn(cmd, cmdArgs, { detached: true, stdio: 'ignore', windowsHide: true });
                 // A missing launcher (e.g. xdg-open absent) emits 'error' asynchronously;
                 // an unhandled 'error' event would throw, so swallow it — the file is
                 // already written and its path printed above.
@@ -6705,6 +6723,7 @@ function autoDetectContext() {
         const diff = execSync('git diff --name-only HEAD 2>&1', {
             encoding: 'utf8',
             timeout: 3000,
+            windowsHide: true,
         }).trim();
         if (diff) {
             // Extract meaningful terms from file paths
@@ -6720,6 +6739,7 @@ function autoDetectContext() {
         const branch = execSync('git branch --show-current 2>&1', {
             encoding: 'utf8',
             timeout: 3000,
+            windowsHide: true,
         }).trim();
         if (branch && branch !== 'main' && branch !== 'master') {
             return branch.replace(/[-_\/]/g, ' ');
@@ -9067,7 +9087,7 @@ Commands:
     --all                  Install for every JSON-hook tool, even if not detected
     --dry-run              Show what would be installed without writing
     --no-schedule          Skip installing or repairing the daily runner
-  last-sleep               Print the last 'hippo sleep --log-file' output and clear it
+  last-sleep               Print the last 'hippo sleep --log-file' output to stderr 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