hippo-memory 1.52.6 → 1.52.8

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];
@@ -484,6 +484,14 @@ function cmdInitScan(scanDir, flags) {
         (totalLowInfo > 0 ? `, ${totalLowInfo} low-information subject(s) dropped` : '') +
         '.');
     console.log(`Global store: ${globalRoot}`);
+    if (!flags['no-hooks']) {
+        // User-level hooks only: a hippo block in each repo's CLAUDE.md or AGENTS.md would leave a diff in every repo.
+        const agents = detectAgentHooks(repos);
+        if (agents.length === 0) {
+            console.log('   No agent config found in these repositories. Run `hippo setup` to add hooks for the agents on this machine.');
+        }
+        installUserLevelHooks(agents, true);
+    }
     if (!flags['no-schedule']) {
         setupDailySchedule(globalRoot);
     }
@@ -520,7 +528,7 @@ function cmdInit(hippoRoot, flags) {
     registerWorkspace(globalRoot, path.dirname(hippoRoot));
     // Auto-detect and install hooks (unless --no-hooks)
     if (!flags['no-hooks']) {
-        autoInstallHooks(alreadyExists);
+        autoInstallHooks();
     }
     // Auto-setup daily schedule (unless --no-schedule)
     if (!flags['no-schedule'] && !flags['global']) {
@@ -539,64 +547,92 @@ 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.`);
         }
     }
 }
-/**
- * Detect agent config files in cwd and auto-install hippo hooks.
- * Skips files that already have a <!-- hippo:start --> block.
- */
-function autoInstallHooks(quiet) {
+/** Plain init: patch the detected agents' instruction files in cwd, then install their user-level hooks. */
+function autoInstallHooks() {
     const cwd = process.cwd();
+    const agents = detectAgentHooks([cwd]);
+    const agentsMd = path.join(cwd, HOOKS.codex.file);
+    // Read before patching: a re-run of init finds its own block and skips the Codex hint.
+    const codexHint = !(fs.existsSync(agentsMd) && fs.readFileSync(agentsMd, 'utf8').includes(HOOK_MARKERS.start));
+    patchInstructionFiles(cwd, agents);
+    installUserLevelHooks(agents, codexHint);
+}
+/** HOOKS keys of the agents with a marker file in any of dirs, in detector order. */
+function detectAgentHooks(dirs) {
     // Map: filename to check -> hook key(s) to install
     const detectors = [
         { files: ['CLAUDE.md', '.claude/settings.json'], hook: 'claude-code' },
         { files: ['AGENTS.md', '.codex'], hook: 'codex' },
-        { files: ['.cursorrules', '.cursor/rules'], hook: 'cursor' },
+        // No Cursor row: Cursor reads the root AGENTS.md, which the rows either side patch.
         { files: ['.openclaw', 'AGENTS.md'], hook: 'openclaw' },
         { files: ['.opencode', 'opencode.json'], hook: 'opencode' },
         { files: ['.pi', '.pi/agent'], hook: 'pi' },
     ];
-    // Track which hook files we've already touched to avoid double-patching AGENTS.md
-    const installed = new Set();
-    for (const { files, hook } of detectors) {
+    return detectors
+        .filter(({ files }) => dirs.some((dir) => files.some((f) => fs.existsSync(path.join(dir, f)))))
+        .map(({ hook }) => hook);
+}
+function patchInstructionFiles(dir, agents) {
+    // One block per file: several agents share AGENTS.md.
+    const seen = new Set();
+    for (const hook of agents) {
         const hookDef = HOOKS[hook];
         if (!hookDef)
             continue;
-        // Check if any marker file exists
-        const detected = files.some((f) => fs.existsSync(path.join(cwd, f)));
-        if (!detected)
+        const targetPath = path.resolve(dir, hookDef.file);
+        // Never create the file: a marker such as .codex or .claude/settings.json does not ask for a new AGENTS.md or CLAUDE.md.
+        if (!fs.existsSync(targetPath) || seen.has(targetPath))
             continue;
-        const targetPath = path.resolve(cwd, hookDef.file);
-        // Skip if we already installed a hook into this file
-        if (installed.has(targetPath))
+        seen.add(targetPath);
+        const existing = fs.readFileSync(targetPath, 'utf8');
+        if (existing.includes(HOOK_MARKERS.start)) {
+            refreshShippedBlock(targetPath, existing, hook);
             continue;
-        // An instruction block already present is not rewritten, but the JSON
-        // hooks and plugins below still run: they are idempotent, and skipping
-        // them meant a store set up by an older hippo never got hooks added in
-        // later releases (PreCompact, PostToolUseFailure) on a re-run of init.
-        const blockPresent = fs.existsSync(targetPath)
-            && fs.readFileSync(targetPath, 'utf8').includes(HOOK_MARKERS.start);
-        // Only patch the agent-instructions file if it already exists.
-        // Never create a new CLAUDE.md / AGENTS.md / etc. just because a sibling
-        // marker file (.claude/settings.json, .codex, etc.) was detected — that
-        // pollutes dirs the user didn't intend to configure.
-        if (!blockPresent && fs.existsSync(targetPath)) {
-            const block = `${HOOK_MARKERS.start}\n${hookDef.content}\n${HOOK_MARKERS.end}`;
-            const existing = fs.readFileSync(targetPath, 'utf8');
-            const sep = existing.endsWith('\n') ? '\n' : '\n\n';
-            fs.writeFileSync(targetPath, existing + sep + block + '\n', 'utf8');
-            installed.add(targetPath);
-            console.log(`   Auto-installed ${hook} hook in ${hookDef.file}`);
-        }
-        // The Codex session-capture wrapper swaps the codex launcher binary, so
-        // init never installs it silently — it points at the explicit opt-in
-        // command instead (issue #133).
-        if (hook === 'codex' && !blockPresent && !isCodexWrapperInstalled()) {
+        }
+        const block = `${HOOK_MARKERS.start}\n${hookDef.content}\n${HOOK_MARKERS.end}`;
+        const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+        fs.writeFileSync(targetPath, existing + sep + block + '\n', 'utf8');
+        console.log(`   Auto-installed ${hook} hook in ${hookDef.file}`);
+    }
+}
+/** The first hippo block in `text` and the agent whose current or shipped text it is; `owner` is undefined for an edited block. */
+function hippoBlock(text) {
+    const at = text.indexOf(HOOK_MARKERS.start);
+    const start = at + HOOK_MARKERS.start.length;
+    const end = text.indexOf(HOOK_MARKERS.end, start);
+    if (at < 0 || end < 0)
+        return null;
+    // git autocrlf checks these files out with CRLF: match as LF, write back in the file's own ending.
+    const raw = text.slice(start, end);
+    const inner = raw.replace(/\r\n/g, '\n').trim();
+    const owner = Object.keys(HOOKS).find((k) => HOOKS[k].content === inner) ?? SHIPPED_HOOK_HASHES.get(createHash('sha256').update(inner).digest('hex'));
+    return { start, end, eol: raw.includes('\r\n') ? '\r\n' : '\n', inner, owner };
+}
+/** Swap an unedited block from an earlier hippo for the current one; an edited block stays, with a hint. */
+function refreshShippedBlock(filePath, text, hook) {
+    const block = hippoBlock(text);
+    if (!block || (block.owner && HOOKS[block.owner].content === block.inner))
+        return;
+    const { start, end, eol, owner } = block;
+    const name = path.basename(filePath);
+    if (!owner) {
+        console.log(`   Left the edited hippo block in ${name} as is; \`hippo hook install ${hook}\` replaces it.`);
+        return;
+    }
+    fs.writeFileSync(filePath, `${text.slice(0, start)}${eol}${HOOKS[owner].content.replace(/\n/g, eol)}${eol}${text.slice(end)}`, 'utf8');
+    console.log(`   Refreshed the ${owner} hippo block in ${name}`);
+}
+/** Claude Code settings hooks and the OpenCode plugin, under the home directory; idempotent, so re-running init adds newer hooks. */
+function installUserLevelHooks(agents, codexHint) {
+    for (const hook of agents) {
+        // The Codex capture wrapper swaps the codex launcher binary, so init only points at the opt-in (issue #133).
+        if (hook === 'codex' && codexHint && !isCodexWrapperInstalled()) {
             console.log('   Codex detected. To capture Codex sessions: hippo hook install codex');
         }
         // For Claude Code, also install SessionEnd+SessionStart entries in its
@@ -674,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
             }
@@ -683,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 {
@@ -696,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 {
@@ -877,6 +913,7 @@ function cmdSupersede(hippoRoot, oldId, newContent, flags) {
         confidence: 'verified',
         tenantId: old.tenantId,
         scope: old.scope,
+        baseHalfLifeDays: loadConfig(hippoRoot).defaultHalfLifeDays,
     });
     // AT1: write the SUCCESSOR first. The rejection guard fires on the new
     // content — if it refuses, nothing has been mutated yet (the old ordering
@@ -1081,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,
@@ -2463,6 +2501,7 @@ function cmdTraceRecord(hippoRoot, flags) {
         trace_outcome: outcome,
         source_session_id: sessionId,
         tenantId: resolveTenantId({}),
+        baseHalfLifeDays: loadConfig(hippoRoot).defaultHalfLifeDays,
     });
     writeEntry(hippoRoot, entry);
     console.log(`Recorded trace ${entry.id} (outcome=${outcome}, ${steps.length} steps)`);
@@ -2485,7 +2524,7 @@ function cmdTrace(hippoRoot, id, flags) {
     }
     const now = evalNow();
     const strength = calculateStrength(entry, now);
-    const halfLife = deriveHalfLife(7, entry);
+    const halfLife = entry.half_life_days;
     const rewardFactor = calculateRewardFactor(entry);
     const effHalfLife = halfLife * rewardFactor;
     const createdMs = new Date(entry.created).getTime();
@@ -2548,7 +2587,7 @@ function cmdTrace(hippoRoot, id, flags) {
     console.log(`  now:        ${fmt(strength, 3)}`);
     console.log(`  in 30 days: ${fmt(projectedAt(30), 3)}`);
     console.log(`  in 90 days: ${fmt(projectedAt(90), 3)}`);
-    console.log(`  half-life:  ${fmt(halfLife, 1)}d (base) x ${fmt(rewardFactor, 2)} reward = ${fmt(effHalfLife, 1)}d effective`);
+    console.log(`  half-life:  ${fmt(halfLife, 1)}d (stored) x ${fmt(rewardFactor, 2)} reward = ${fmt(effHalfLife, 1)}d effective`);
     console.log();
     console.log(`Retrieval:`);
     console.log(`  count:      ${entry.retrieval_count}`);
@@ -2606,28 +2645,47 @@ 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({}));
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
     let imported = 0;
     let skippedSecret = 0;
     // AT1 (plan §3 containment): a rejection guard refusal is per-VALUE — one
@@ -2671,6 +2729,7 @@ export function learnFromMemoryMd(hippoRoot, homeDir = os.homedir()) {
                     source: `claude-memory:${file}`,
                     confidence: 'observed',
                     tenantId: resolveTenantId({}),
+                    baseHalfLifeDays,
                 });
                 try {
                     writeEntry(hippoRoot, entry);
@@ -2854,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);
@@ -2875,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 = {
@@ -2892,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']
@@ -2912,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 {
@@ -3093,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 {
@@ -3102,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;
     }
@@ -3119,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');
@@ -3154,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) {
@@ -6086,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.
@@ -6664,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
@@ -6679,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, ' ');
@@ -6839,7 +6900,8 @@ function learnFromRepo(hippoRoot, repoPath, days, label) {
     }
     // Same patterns as MCP hippo_learn: config.gitLearnPatterns (whose default
     // equals extractLessons' built-in list) so a custom list applies everywhere.
-    const parsedLessons = extractLessons(gitLog, loadConfig(hippoRoot).gitLearnPatterns);
+    const config = loadConfig(hippoRoot);
+    const parsedLessons = extractLessons(gitLog, config.gitLearnPatterns);
     if (parsedLessons.length === 0) {
         console.log(`${prefix}No fix/revert/bug commits found in the specified period.`);
         return { added: 0, skipped: 0, lowInfo: 0 };
@@ -6905,6 +6967,7 @@ function learnFromRepo(hippoRoot, repoPath, days, label) {
             confidence: 'observed',
             schema_fit: schemaFitVal,
             tenantId: resolveTenantId({}),
+            baseHalfLifeDays: config.defaultHalfLifeDays,
         });
         // Auto-tag with path context from the repo being learned
         const learnPathTags = extractPathTags(repoPath);
@@ -7180,25 +7243,14 @@ run it if the hook is not installed:
 hippo context --auto --budget 1500
 \`\`\`
 
-When you learn something important:
-\`\`\`bash
-hippo remember "<lesson>"
-\`\`\`
-
-When you hit an error or discover a gotcha:
+When you find out why something failed, record it right then, while you
+work, never as a closing step:
 \`\`\`bash
 hippo remember "<what went wrong and why>" --error
 \`\`\`
 
-After completing work successfully:
-\`\`\`bash
-hippo outcome --good
-\`\`\`
-
-When the user ends the session, capture a brief summary:
-\`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
-\`\`\`
+The installed hooks store failed tool calls and capture the session when it
+ends, so there is nothing to run before you finish.
 `.trim(),
     },
     'codex': {
@@ -7213,34 +7265,41 @@ hippo context --auto --budget 1500
 \`\`\`
 Read the output before writing any code.
 
-On errors or unexpected behaviour:
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
 \`\`\`bash
 hippo remember "<description of what went wrong>" --error
 \`\`\`
 
-On task completion:
-\`\`\`bash
-hippo outcome --good
-\`\`\`
-
 When Hippo's Codex wrapper is installed, session-end capture runs automatically.
 If the wrapper is not installed, capture a brief summary manually:
 \`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
 \`\`\`
 `.trim(),
     },
     'cursor': {
-        file: '.cursorrules',
+        file: 'AGENTS.md',
         description: 'Cursor',
         content: `
-# Project Memory (Hippo)
-# Before each task, load context:
-#   hippo context --auto --budget 1500
-# After errors:
-#   hippo remember "<error description>" --error
-# After completing:
-#   hippo outcome --good
+## Project Memory (Hippo)
+
+At the start of every task, run:
+\`\`\`bash
+hippo context --auto --budget 1500
+\`\`\`
+Read the output before writing any code.
+
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
+\`\`\`bash
+hippo remember "<description of what went wrong>" --error
+\`\`\`
+
+When ending a session, capture a brief summary:
+\`\`\`bash
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
+\`\`\`
 `.trim(),
     },
     'openclaw': {
@@ -7255,19 +7314,15 @@ hippo context --auto --budget 1500
 \`\`\`
 Read the output before writing any code.
 
-On errors or unexpected behaviour:
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
 \`\`\`bash
 hippo remember "<description of what went wrong>" --error
 \`\`\`
 
-On task completion:
-\`\`\`bash
-hippo outcome --good
-\`\`\`
-
 When ending a session, capture a brief summary:
 \`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
 \`\`\`
 `.trim(),
     },
@@ -7283,7 +7338,8 @@ hippo context --auto --budget 1500
 \`\`\`
 Read the output before writing any code.
 
-When you learn something important or hit an error:
+When you learn a non-obvious lesson or hit an error, record it right then,
+while you work, never as a closing step:
 \`\`\`bash
 hippo remember "<lesson>" --error
 \`\`\`
@@ -7293,14 +7349,9 @@ When stuck or repeating yourself, check if this happened before:
 hippo recall "<what's going wrong>" --budget 2000
 \`\`\`
 
-On task completion:
-\`\`\`bash
-hippo outcome --good
-\`\`\`
-
 When ending a session, capture a brief summary:
 \`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
 \`\`\`
 `.trim(),
     },
@@ -7316,28 +7367,44 @@ hippo context --auto --budget 1500
 \`\`\`
 Read the output before writing any code.
 
-On errors or unexpected behaviour:
+On errors or unexpected behaviour, record it right then, while you work,
+never as a closing step:
 \`\`\`bash
 hippo remember "<description of what went wrong>" --error
 \`\`\`
 
-On task completion:
-\`\`\`bash
-hippo outcome --good
-\`\`\`
-
 When ending a session, capture a brief summary:
 \`\`\`bash
-hippo capture --stdin <<< '<decisions, errors, lessons — 2-5 bullets>'
+hippo capture --stdin <<< '<decisions, errors, lessons: 2-5 bullets>'
 \`\`\`
 
 For full integration, copy the hippo-memory Pi extension to \`~/.pi/agent/extensions/hippo-memory/\`.
 `.trim(),
     },
 };
+// sha256 of each trimmed block an earlier hippo wrote, so init refreshes only blocks nobody edited. Add the old hash when a block changes.
+const SHIPPED_HOOK_HASHES = new Map([
+    ['c04e48f2896a4fee9ae98f8f832e2d26a3910269df3beb5bcd6baee3cd9db68e', 'claude-code'],
+    ['e6b12bd8983c032e5ca8e95a97aeff4178a5a05026d10acad5b2e1b25d5656dd', 'claude-code'],
+    ['4c64e11d3e5be68fa547c9248d7553feb645a02f7cf13ba02f7275e1854baf44', 'claude-code'],
+    ['293bd319bbc86225a0ee027490a3322a0336257f5832f7fade65e4ffb2530654', 'claude-code'],
+    ['15abcece9712279fb4721f7a8f0ba117457400278977beb5cf5b5d7ba49f7b1a', 'codex'],
+    ['0c81a6b2c21473313001f624b80ea870e661aecbfda9bfe8503febc0d5f34533', 'codex'],
+    ['88e45358aba4f17912f113221c991dc758275991335d1daa4aa1974a69c46769', 'codex'],
+    ['a1415ecda9b2f8f317c233738e4a5ac16e6b2cc385a017c0c8ecfbfacbcab6a3', 'cursor'],
+    ['a38c428bbdfc14ec50f6f7b9183785170a4eae1ce9cde60257cca6efc7206b3a', 'cursor'],
+    ['40524c3bd5a2eb04036567cc761451961d950995768bccd93a9900b0f75eafea', 'openclaw'],
+    ['7b3518e8c0feaa7b8b454cde7743f7598ad14cd9979e1680d0954484e2464aae', 'openclaw'],
+    ['4601c67c31f41cd5b1324cfccdb1afc66872b7fb0bc1e7c5789ecabb1f6bd942', 'opencode'],
+    ['90d9e21d8d1ecbe99a0fc7b7f2d9f8af7b5315a6b4b0203df4f7a9bdc0699b98', 'opencode'],
+    ['8b8f5986d7f7ed15f06e68720d8913c3cab23d94366b411935ca2bbaa334553b', 'pi'],
+    ['37767b355e18beac726b05b9e2b898dab8c6135fd7b98f3aa52edc734d5dd283', 'pi'],
+]);
 function cmdHook(args, flags) {
     const subcommand = args[0];
     const target = args[1];
+    // Cursor has no init row, so the AGENTS.md block is usually another agent's, and Cursor reads that one as it is.
+    const othersBlock = (text) => target === 'cursor' && hippoBlock(text)?.owner !== 'cursor';
     if (subcommand === 'list') {
         console.log('Available hooks:\n');
         for (const [name, hook] of Object.entries(HOOKS)) {
@@ -7359,7 +7426,10 @@ function cmdHook(args, flags) {
         let agentFileTouched = false;
         if (fs.existsSync(filepath)) {
             const existing = fs.readFileSync(filepath, 'utf8');
-            if (existing.includes(HOOK_MARKERS.start)) {
+            if (existing.includes(HOOK_MARKERS.start) && othersBlock(existing)) {
+                console.log(`${hook.file} already has a hippo block, which Cursor reads; left it as is.`);
+            }
+            else if (existing.includes(HOOK_MARKERS.start)) {
                 const re = new RegExp(`${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}`, 'g');
                 const updated = existing.replace(re, block);
                 fs.writeFileSync(filepath, updated, 'utf8');
@@ -7447,10 +7517,13 @@ function cmdHook(args, flags) {
         const filepath = path.resolve(process.cwd(), hook.file);
         if (fs.existsSync(filepath)) {
             const existing = fs.readFileSync(filepath, 'utf8');
-            if (existing.includes(HOOK_MARKERS.start)) {
-                const re = new RegExp(`\\n?${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}\\n?`, 'g');
-                const cleaned = existing.replace(re, '\n').replace(/\n{3,}/g, '\n\n').trim();
-                fs.writeFileSync(filepath, cleaned + '\n', 'utf8');
+            if (existing.includes(HOOK_MARKERS.start) && othersBlock(existing)) {
+                const owner = hippoBlock(existing)?.owner;
+                const whose = owner ? `hippo wrote it for ${owner}` : 'it has been edited, so hippo cannot tell whose it is';
+                console.log(`Left the hippo block in ${hook.file}: ${whose}. Delete it by hand if no agent needs it.`);
+            }
+            else if (existing.includes(HOOK_MARKERS.start)) {
+                fs.writeFileSync(filepath, withoutHookBlock(existing) + '\n', 'utf8');
                 console.log(`Removed Hippo hook from ${hook.file}`);
             }
             else {
@@ -7479,11 +7552,28 @@ function cmdHook(args, flags) {
                 console.log('Removed Codex wrapper integration');
             }
         }
+        else if (target === 'cursor') {
+            // Older hippo wrote Cursor's block to .cursorrules, creating the file when it was missing.
+            const legacy = path.resolve(process.cwd(), '.cursorrules');
+            const old = fs.existsSync(legacy) ? fs.readFileSync(legacy, 'utf8') : '';
+            if (old.includes(HOOK_MARKERS.start)) {
+                const left = withoutHookBlock(old);
+                if (left)
+                    fs.writeFileSync(legacy, left + '\n', 'utf8');
+                else
+                    fs.unlinkSync(legacy);
+                console.log(left ? 'Removed the old Hippo hook from .cursorrules' : 'Deleted .cursorrules, which held only the old Hippo hook');
+            }
+        }
         return;
     }
     console.error('Usage: hippo hook <install|uninstall|list> [target]');
     process.exit(1);
 }
+function withoutHookBlock(text) {
+    const re = new RegExp(`\\n?${escapeRegex(HOOK_MARKERS.start)}[\\s\\S]*?${escapeRegex(HOOK_MARKERS.end)}\\n?`, 'g');
+    return text.replace(re, '\n').replace(/\n{3,}/g, '\n\n').trim();
+}
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -8997,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