hippo-memory 1.52.9 → 1.53.1

package/dist/cli.js

@@ -37,11 +37,10 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
 import { fileURLToPath } from 'node:url';
-import { execFileSync, execSync, spawn, spawnSync } from 'child_process';
+import { execFileSync, execSync, spawn } from 'child_process';
 import { installJsonHooks, uninstallJsonHooks, resolveJsonHookPaths, detectInstalledTools, defaultSleepLogPath, ensureCodexWrapperInstalled, installCodexWrapper, detectRealCodexPath, isCodexPresent, isCodexWrapperInstalled, CODEX_TRUST_LINE, 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';
-import { getHippoRoot, isInitialized, initStore, writeEntry, strengthenRetrieved, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, createCard, loadCard, listCards, loadCardRuns, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, } from './store.js';
+import { createMemory, createSuccessor, calculateStrength, calculateRewardFactor, deriveHalfLife, resolveConfidence, confidenceFacets, confidenceLabel, computeSchemaFit, Layer, } from './memory.js';
+import { getHippoRoot, isInitialized, initStore, writeEntry, strengthenRetrieved, readEntry, deleteEntry, loadAllEntries, loadSearchEntries, loadRecallSearchEntries, loadIndex, saveIndex, loadStats, updateStats, saveActiveTaskSnapshot, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, closeTaskSnapshotsForSession, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, listMemoryConflicts, resolveConflict, saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome, writeSessionEndHandoff, createCard, loadCard, listCards, loadCardRuns, claimCard, heartbeatCard, blockCard, reviewCard, completeCard, reclaimExpiredCards, addCardComment, memoriesBackingObjects, } from './store.js';
 import { rejectValue, unrejectValue, listRejectionsForTenant } from './reject-flow.js';
 import { RejectedValueError } from './rejection.js';
 import { isHandoffOutcome, formatHandoffEvidenceLine } from './handoff.js';
@@ -70,14 +69,17 @@ import { pushGoal, getActiveGoals, completeGoal, suspendGoal, resumeGoal, applyG
 import { rowToGoal } from './goals.js';
 import { captureError, extractLessons, partitionLessons, runWatched, fetchGitLog, isGitRepo, } from './autolearn.js';
 import { dropHeldCopies, duplicateKey, storedTextKeys } from './same-text.js';
+import { currentMachine, importAtCompaction, importAtSessionEnd, importForStore, importProjectMemories, importUserMemories, } from './agent-memories/sync.js';
+import { detailLines, emptyReport, mergeReports, summaryLine } from './agent-memories/report.js';
 import { extractInvalidationTarget, invalidateMatching, detectChurnStale } from './invalidation.js';
-import { deriveOriginProject, realpathOrResolve, resolveProjectIdentity } from './project-identity.js';
+import { deriveOriginProject, isGlobalStoreRoot, 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, buildSchtasksCreateArgs, buildWindowsTaskRun, listRegisteredWorkspaces, registerWorkspace, runDailyMaintenance, } from './scheduler.js';
 import { importChatGPT, importClaude, importCursor, importGenericFile, importMarkdown, importVault, } from './importers.js';
-import { cmdCapture, cmdPreCompact, postCompactMessage, resolveLastSessionTranscript, truncateCodePointSafe, sanitizeLogMessage, transcriptWorkingState } from './capture.js';
+import { cmdCapture, cmdPreCompact, cmdPostCompact, resolveLastSessionTranscript, truncateCodePointSafe, sanitizeLogMessage, transcriptWorkingState } from './capture.js';
+import { COMPACTION_DB_WAIT_MS, replayCompactionsAt } from './compaction-record.js';
 import { readStdinBounded } from './stdin.js';
 import { auditMemories, appendAuditEvent, AUDIT_OPS, } from './audit.js';
 import { listApiKeys, revokeApiKey } from './auth.js';
@@ -285,7 +287,7 @@ async function runViaServerIfAvailable(hippoRoot, httpFn) {
 // and as off under === true (`--pin=true` would not pin), so parseArgs and main() refuse one.
 // tests/cli-parse-flag-equals.test.ts fails when a switch read is missing from this set.
 export const BOOLEAN_FLAGS = new Set([
-    'all', 'all-tenants', 'archive', 'auto', 'bad', 'bootstrap', 'classic', 'churn', 'continuity',
+    'agents', 'all', 'all-tenants', 'archive', 'auto', 'bad', 'bootstrap', 'classic', 'churn', 'continuity',
     'cross-project', 'dry-run', 'equal-sources', 'error', 'evc-adaptive', 'extract',
     'filter-conflicts', 'fix', 'force', 'forget', 'git', 'global', 'good', 'graph-stream',
     'help', 'include-logs', 'include-superseded', 'inferred', 'json', 'last-session', 'multihop', 'no-hooks',
@@ -528,6 +530,8 @@ function cmdInitScan(scanDir, flags) {
     // that a dropped subject is never invisible.
     let totalLowInfo = 0;
     const seedDays = parseInt(String(flags['days'] ?? '365'), 10);
+    const machine = currentMachine();
+    const agentImport = emptyReport();
     for (const repo of repos) {
         const name = path.basename(repo);
         const repoHippo = path.join(repo, '.hippo');
@@ -544,6 +548,8 @@ function cmdInitScan(scanDir, flags) {
             totalLessons += added;
             totalLowInfo += result.lowInfo;
         }
+        if (!flags['no-learn'])
+            mergeReports(agentImport, importProjectMemories(repoHippo, { machine }));
         const status = alreadyExists ? 'existing' : 'new';
         const entries = loadAllEntries(repoHippo);
         console.log(`  ${name.padEnd(25)} ${status.padEnd(10)} ${entries.length} memories${added > 0 ? ` (+${added} from git)` : ''}`);
@@ -551,6 +557,10 @@ function cmdInitScan(scanDir, flags) {
     console.log(`\n${repos.length} repositories, ${totalLessons} new lessons learned` +
         (totalLowInfo > 0 ? `, ${totalLowInfo} low-information subject(s) dropped` : '') +
         '.');
+    if (!flags['no-learn']) {
+        mergeReports(agentImport, importUserMemories(globalRoot, { machine }));
+        printAgentImport(agentImport, '');
+    }
     console.log(`Global store: ${globalRoot}`);
     if (initInstallsIntegrations(flags)) {
         // User-level hooks only: a hippo block in each repo's CLAUDE.md or AGENTS.md would leave a diff in every repo.
@@ -576,10 +586,13 @@ function cmdInit(hippoRoot, flags) {
         const globalRoot = getGlobalRoot();
         if (isInitialized(globalRoot)) {
             console.log('Already initialized global store at', globalRoot);
-            return;
         }
-        initGlobal();
-        console.log('Initialized global Hippo store at', globalRoot);
+        else {
+            initGlobal();
+            console.log('Initialized global Hippo store at', globalRoot);
+        }
+        if (!flags['no-learn'])
+            printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }));
         return;
     }
     const alreadyExists = isInitialized(hippoRoot);
@@ -614,11 +627,18 @@ function cmdInit(hippoRoot, flags) {
                 console.log(`   No matching commits found in git history.`);
             }
         }
-        const memImported = learnFromMemoryMd(hippoRoot);
-        if (memImported > 0) {
-            console.log(`   Imported ${memImported} memories from this project's Claude Code auto memory.`);
-        }
     }
+    // Every run, not only the first: an agent's notes change between inits.
+    if (!flags['no-learn'])
+        printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }));
+}
+/** One line when an agent memory import moved anything; its warnings go to stderr. */
+function printAgentImport(report, indent = '   ') {
+    const line = summaryLine(report);
+    if (line !== null)
+        console.log(`${indent}${line}`);
+    for (const warning of report.warnings)
+        console.error(`hippo: agent memories: ${warning}`);
 }
 /** Every write init makes into agent config (instruction blocks, hooks, plugins) is an automatic integration, so one switch skips them all. */
 function initInstallsIntegrations(flags) {
@@ -990,23 +1010,20 @@ function cmdSupersede(hippoRoot, oldId, newContent, flags) {
         console.error(`Error: memory ${oldId} is already superseded by ${old.superseded_by}. Supersede that one instead.`);
         process.exit(1);
     }
-    const layer = (typeof flags['layer'] === 'string' ? flags['layer'] : old.layer);
+    const layer = typeof flags['layer'] === 'string' ? flags['layer'] : undefined;
     const rawTags = flags['tag'];
     const tags = Array.isArray(rawTags)
         ? rawTags.map((t) => String(t))
         : typeof rawTags === 'string'
             ? rawTags.split(',').map((t) => t.trim()).filter(Boolean)
-            : [...old.tags];
+            : undefined;
     const pinned = flags['pin'] === true || old.pinned;
-    const newEntry = createMemory(newContent, {
+    const newEntry = createSuccessor(old, newContent, {
+        tenantId: old.tenantId,
+        baseHalfLifeDays: loadConfig(hippoRoot).defaultHalfLifeDays,
         layer,
         tags,
         pinned,
-        source: old.source,
-        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
@@ -1047,6 +1064,7 @@ async function cmdRecall(hippoRoot, query, flags) {
         process.exit(1);
     }
     const globalRoot = getGlobalRoot();
+    const primaryIsGlobal = isGlobalStoreRoot(hippoRoot);
     // A5 stub auth: resolve the active tenant once and thread it through every
     // recall-time SELECT against `memories`. Cross-tenant rows must never surface.
     const tenantId = resolveTenantId({});
@@ -1066,7 +1084,9 @@ async function cmdRecall(hippoRoot, query, flags) {
     const requestedScopeForFilter = recallExplicitScope || undefined;
     const loadSuperseded = includeSuperseded || Boolean(asOf);
     let localEntries = loadRecallSearchEntries(hippoRoot, query, undefined, tenantId, requestedScopeForFilter, 'additive', loadSuperseded);
-    let globalEntries = isInitialized(globalRoot) ? loadRecallSearchEntries(globalRoot, query, undefined, tenantId, requestedScopeForFilter, 'additive', loadSuperseded) : [];
+    let globalEntries = globalRoot !== hippoRoot && isInitialized(globalRoot)
+        ? loadRecallSearchEntries(globalRoot, query, undefined, tenantId, requestedScopeForFilter, 'additive', loadSuperseded)
+        : [];
     // v1.12.13 / C5 — WYSIATI counters. Track filter activity per the plan v3
     // Task 3 mapping table. dropped_pre_rank is the SUM of all non-budget
     // filter drops (pre-rank AND post-rank); its meaning is unchanged by C5.
@@ -1192,7 +1212,7 @@ async function cmdRecall(hippoRoot, query, flags) {
     // Engines spend the budget on the text each result prints as, less the header, so selection and print agree.
     const localIndex = loadIndex(hippoRoot);
     const globalOn = isInitialized(globalRoot);
-    const entryText = (r) => recallEntryText(r, query, showWhy, globalOn && !localIndex.entries[r.entry.id]);
+    const entryText = (r) => recallEntryText(r, query, showWhy, primaryIsGlobal || (globalOn && !localIndex.entries[r.entry.id]));
     const printCost = (r) => printedTokens(entryText(r));
     const entryBudget = Math.max(0, budget - printedTokens(recallHeading(budget, budget, query)));
     let results;
@@ -1699,7 +1719,7 @@ async function cmdRecall(hippoRoot, query, flags) {
     let activeSnapshot = null;
     let sessionHandoff = null;
     let recentSessionEvents = [];
-    if (includeContinuity) {
+    if (includeContinuity && !primaryIsGlobal) {
         const rawSnapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
         const sessionId = rawSnapshot?.session_id ?? undefined;
         const rawHandoff = sessionId
@@ -1958,7 +1978,7 @@ async function cmdRecall(hippoRoot, query, flags) {
     updateStats(hippoRoot, { recalled: results.length });
     if (asJson) {
         const output = results.map((r) => {
-            const isGlobal = isInitialized(globalRoot) && !localIndex.entries[r.entry.id];
+            const isGlobal = primaryIsGlobal || (isInitialized(globalRoot) && !localIndex.entries[r.entry.id]);
             const base = {
                 id: r.entry.id,
                 score: r.score,
@@ -2605,112 +2625,6 @@ async function cmdRefine(hippoRoot, flags) {
         }
     }
 }
-/** 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()) {
-    // 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 keys = storedTextKeys(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
-    // tombstoned memory file must not abort the whole directory scan. No
-    // signature change (bare number return, cli.ts:540 + cli.ts:2903 callers
-    // unchanged) — counted internally and printed as one summary line.
-    let rejected = 0;
-    for (const memDir of memoryDirs) {
-        try {
-            const files = fs.readdirSync(memDir).filter(f => f.endsWith('.md') && f !== 'MEMORY.md');
-            for (const file of files) {
-                const raw = fs.readFileSync(path.join(memDir, file), 'utf8');
-                // Parse YAML frontmatter
-                const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-                if (!fmMatch)
-                    continue;
-                const body = fmMatch[2].trim();
-                if (!body || body.length < 10)
-                    continue;
-                // Truncate to reasonable size
-                const content = body.length > 1500 ? body.slice(0, 1500) + ' [truncated]' : body;
-                // Never ingest secret-bearing memory files. Some Claude Code memory
-                // files exist purely to hold a live credential (e.g. an API-key
-                // reference). The scope-isolation secret veto (v1.24.0) gated
-                // share/promote/sync/ambient but missed this import path, so a live
-                // key could land in the store here. Veto it at ingest. (v1.24.1)
-                if (detectSecret({ content, tags: ['claude-code-memory'] }).flagged) {
-                    skippedSecret++;
-                    continue;
-                }
-                // Dedup: skip only when the same text is already stored
-                if (keys.has(duplicateKey(content)))
-                    continue;
-                const entry = createMemory(content, {
-                    layer: Layer.Episodic,
-                    tags: ['claude-code-memory'],
-                    source: `claude-memory:${file}`,
-                    confidence: 'observed',
-                    tenantId: resolveTenantId({}),
-                    baseHalfLifeDays,
-                });
-                try {
-                    writeEntry(hippoRoot, entry);
-                }
-                catch (err) {
-                    if (err instanceof RejectedValueError) {
-                        rejected++;
-                        continue;
-                    }
-                    throw err;
-                }
-                keys.add(duplicateKey(content)); // prevent self-dedup within batch
-                imported++;
-            }
-        }
-        catch { /* skip broken dirs */ }
-    }
-    if (skippedSecret > 0) {
-        console.log(`Skipped ${skippedSecret} secret-bearing memory file${skippedSecret === 1 ? '' : 's'} (not ingested).`);
-    }
-    if (rejected > 0) {
-        console.log(`Skipped ${rejected} rejected value${rejected === 1 ? '' : 's'} (run \`hippo unreject\` to allow).`);
-    }
-    return imported;
-}
 function cmdDedup(hippoRoot, flags) {
     requireInit(hippoRoot);
     const dryRun = Boolean(flags['dry-run']);
@@ -2871,10 +2785,10 @@ export function renderSleepResult(result) {
 }
 async function cmdSleepCore(hippoRoot, flags) {
     requireInit(hippoRoot);
-    // Phase 1: Auto-learn from git + Claude Code auto memory (CLI-only, uses process.cwd() / os.homedir()).
+    // Phase 1: Auto-learn from git and every coding agent's own memories (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 this project's Claude Code auto memory.");
+        console.log("Dry run: skipped learning from git commits and coding agents' own memories (`hippo import --agents --dry-run` previews those).");
     }
     else if (!flags['no-learn']) {
         const config = loadConfig(hippoRoot);
@@ -2892,9 +2806,13 @@ async function cmdSleepCore(hippoRoot, flags) {
                     console.error(`Churn-staleness check failed for ${root}: ${result.error}`);
             }
         }
-        const memImported = learnFromMemoryMd(hippoRoot);
-        if (memImported > 0)
-            console.log(`Imported ${memImported} memories from this project's Claude Code auto memory.`);
+        printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }), '');
+    }
+    // Finishes compactions a killed or busy post-compact hook left; never throws, and a dry run writes nothing.
+    if (!flags['dry-run']) {
+        const finished = replayCompactionsAt(hippoRoot, (message) => console.error(`compaction replay: ${message}`));
+        if (finished > 0)
+            console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over from earlier sessions.`);
     }
     // Phase 2-6: Pure-storage pipeline (consolidate + dedup + audit + share + ambient).
     const ctx = {
@@ -3068,7 +2986,7 @@ async function cmdSessionEnd(hippoRoot, flags) {
     // Bounded read (DF1 T3, docs/plans/2026-08-23-df1-snapshot-lifecycle.md):
     // extracts transcript_path + session_id for the detached worker's argv.
     let sessionId = null;
-    const { text: stdinText, timedOut: stdinTimedOut } = await readStdinBounded();
+    const { text: stdinText } = await readStdinBounded();
     try {
         if (stdinText && stdinText.trim().startsWith('{')) {
             const payload = JSON.parse(stdinText);
@@ -3081,7 +2999,8 @@ async function cmdSessionEnd(hippoRoot, flags) {
         // No stdin, not JSON, or read failure: the snapshot close below will no-op.
     }
     // Resolved here because only this process saw the payload; the worker captures just the path it is handed.
-    const transcriptPath = resolveLastSessionTranscript(undefined, stdinText, stdinTimedOut);
+    // Always a hook, so never scan: an empty stdin here is not a manual run.
+    const transcriptPath = resolveLastSessionTranscript(undefined, stdinText, { mayScan: false });
     const workerArgs = [process.argv[1], '__session-end-worker'];
     if (logFile)
         workerArgs.push('--log-file', logFile);
@@ -3136,6 +3055,20 @@ function collectHandoffEvidence(cwd, testStatus) {
     }
     return { gitRef, dirtyTree, testStatus };
 }
+/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
+function logSessionEndImport(logFile, transcriptPath) {
+    try {
+        const report = importAtSessionEnd(process.cwd(), transcriptPath, { machine: currentMachine() });
+        const line = summaryLine(report);
+        if (line !== null)
+            appendSessionEndCloseLog(logFile, line);
+        for (const warning of report.warnings)
+            appendSessionEndCloseLog(logFile, `agent memories: ${warning}`);
+    }
+    catch (err) {
+        appendSessionEndCloseLog(logFile, `agent memory import failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 async function cmdSessionEndWorker(hippoRoot, flags) {
     const transcriptPath = typeof flags['transcript'] === 'string' ? flags['transcript'] : undefined;
     const closeLogFile = typeof flags['log-file'] === 'string' ? flags['log-file'] : null;
@@ -3165,6 +3098,7 @@ async function cmdSessionEndWorker(hippoRoot, flags) {
     }
     else {
         appendSessionEndCloseLog(closeLogFile, 'skip sleep: this folder has no store of its own', { startFresh: true });
+        logSessionEndImport(closeLogFile, transcriptPath);
     }
     flushRereadLog();
     const digestLog = (message) => appendSessionEndCloseLog(closeLogFile, message);
@@ -3407,6 +3341,7 @@ async function cmdCodexSessionEndWorker(hippoRoot, flags) {
     }
     else {
         appendSessionEndCloseLog(logFile ?? null, 'skip sleep: this folder has no store of its own', { startFresh: true });
+        logSessionEndImport(logFile ?? null, undefined);
     }
     try {
         const codexHome = typeof flags['codex-home'] === 'string'
@@ -7000,6 +6935,18 @@ function cmdImport(hippoRoot, args, flags) {
             ? [String(flags['tag'])]
             : [];
     const targetRoot = useGlobal ? getGlobalRoot() : hippoRoot;
+    if (flags['agents']) {
+        const opts = { machine: currentMachine(), dryRun };
+        // A folder without a store of its own imports as session end would there, so its notes are not hidden.
+        const report = useGlobal || isInitialized(hippoRoot)
+            ? importForStore(useGlobal ? getGlobalRoot() : hippoRoot, opts)
+            : importAtSessionEnd(process.cwd(), undefined, opts);
+        for (const line of detailLines(report, dryRun))
+            console.log(line);
+        for (const warning of report.warnings)
+            console.error(`hippo: agent memories: ${warning}`);
+        return;
+    }
     if (useGlobal) {
         initGlobal();
     }
@@ -7105,7 +7052,7 @@ function cmdImport(hippoRoot, args, flags) {
         importerName = 'File';
     }
     if (!filePath || !importer) {
-        console.error('Usage: hippo import <--chatgpt|--claude|--cursor|--file|--markdown|--vault> <path>');
+        console.error('Usage: hippo import <--chatgpt|--claude|--cursor|--file|--markdown|--vault> <path>, or hippo import --agents [--dry-run]');
         process.exit(1);
     }
     if (!fs.existsSync(filePath)) {
@@ -7718,11 +7665,22 @@ function cmdSetup(flags) {
             setupDailySchedule(globalRoot);
         }
     }
+    if (!flags['no-learn']) {
+        console.log('');
+        printAgentImport(importUserMemories(globalRoot, { machine: currentMachine(), dryRun }), dryRun ? '[dry-run] ' : '');
+    }
     console.log('');
     console.log('Done. Restart your AI tool to activate the hooks.');
 }
 function cmdDailyRunner() {
     const globalRoot = getGlobalRoot();
+    // No workspace sleep ever opens the global store, yet hooks in folders without a store compact into it.
+    if (isInitialized(globalRoot)) {
+        const finished = replayCompactionsAt(globalRoot, (message) => console.error(`compaction replay: ${message}`));
+        if (finished > 0)
+            console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over in the global store.`);
+    }
+    printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }), '');
     const workspaces = listRegisteredWorkspaces(globalRoot);
     if (workspaces.length === 0) {
         console.log('No registered Hippo workspaces found. Run `hippo init` inside a project first.');
@@ -7749,23 +7707,6 @@ function cmdDailyRunner() {
     });
     console.log(`Daily maintenance complete: ${processed} workspace${processed === 1 ? '' : 's'} processed, ${failed} command failure${failed === 1 ? '' : 's'}.`);
 }
-// JSON-hook install/uninstall lives in ./hooks.ts so tests can import it
-// without running the CLI main(). Backwards-compatible wrappers below keep
-// older call sites working.
-function installClaudeCodeSessionEndHook() {
-    const result = installJsonHooks('claude-code');
-    return {
-        installed: result.installedSessionEnd ||
-            result.installedSessionStart ||
-            result.installedUserPromptSubmit ||
-            result.installedPreCompact ||
-            result.installedCompactResume,
-        migratedFromStop: result.migratedFromStop,
-    };
-}
-function uninstallClaudeCodeSessionEndHook() {
-    return uninstallJsonHooks('claude-code');
-}
 // ---------------------------------------------------------------------------
 // Working Memory
 // ---------------------------------------------------------------------------
@@ -8704,7 +8645,8 @@ Commands:
     --no-hooks             Skip auto-detecting and installing agent hooks
                            (HIPPO_SKIP_AUTO_INTEGRATIONS=1 does the same)
     --no-schedule          Skip auto-creating the machine-level daily runner
-    --no-learn             Skip seeding memories from git history
+    --no-learn             Skip seeding memories from git history and importing
+                           coding agents' own memories (every init imports those)
   remember <text>          Store a memory
     --tag <tag>            Add a tag (repeatable)
     --error                Tag as error (boosts retention)
@@ -8841,7 +8783,7 @@ Commands:
                            With ANTHROPIC_API_KEY set it sends memory text to Anthropic for
                            fact extraction; {"extraction":{"enabled":false}} turns that off
     --dry-run              Preview without writing
-    --no-learn             Skip auto git-learn before consolidation
+    --no-learn             Skip auto git-learn and the agent memory import before consolidation
     --no-share             Skip auto-sharing to global store
   daily-runner             Sweep registered workspaces and run daily learn+sleep
   dedup                    Remove duplicate memories (keeps stronger copy)
@@ -9039,6 +8981,11 @@ Commands:
     --vault <path>         Import a markdown-vault FOLDER as kind='raw' notes
                              (Obsidian/Foam/Dendron). Requires --name <vault>.
                              [--scope <scope>]
+    --agents               Sync every coding agent's own memories (Claude Code, Codex,
+                             Gemini CLI, Copilot, OpenClaw, Qwen Code) now; with
+                             --dry-run, print each tool's folders and what would change.
+                             HIPPO_AGENT_MEMORY_TOOLS=<ids> or config agentMemories.tools
+                             picks the tools; "none" or [] turns the import off
     --dry-run              Preview without writing
     --global               Write to global store ($HIPPO_HOME or ~/.hippo/)
     --tag <tag>            Add extra tag (repeatable)
@@ -9056,10 +9003,12 @@ Commands:
   setup                    One-shot: detect installed AI tools and install their hooks:
                            claude-code gets 7 hooks in ~/.claude/settings.json, opencode
                            a plugin, codex 2 hooks in its hooks.json plus a launcher
-                           wrapper; other tools get a hint
+                           wrapper; other tools get a hint. Then imports each agent's
+                           user-level memories into the global store
     --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
+    --no-learn             Skip the agent memory import
   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
@@ -9067,10 +9016,12 @@ Commands:
                            capture from the session's last 20 user and 10 assistant messages,
                            in a detached worker
     --log-file <path>      Tee the worker's output to a log file (paired with 'hippo last-sleep')
-  pre-compact              PreCompact hook: save a working-state snapshot before compaction
+  pre-compact              PreCompact hook: record the compaction, save a working-state snapshot, and
+                           ask the summariser to end with a "Memories for hippo" list
     --log-file <p>         Diagnostic log path (default: ~/.hippo/logs/pre-compact.log)
   compact-resume           SessionStart(compact) hook: re-print the snapshot, if under 15 minutes old
-  post-compact             PostCompact hook: tell the user what pre-compact saved
+  post-compact             PostCompact hook: keep that list as memories (a busy store leaves the save to
+                           the next hippo sleep) and print one line saying how many
     --log-file <p>         Same log path as pre-compact (default: ~/.hippo/logs/pre-compact.log)
   codex-run [-- ...args]   Launch real Codex behind Hippo's session-end wrapper
   hook <sub> [target]      Manage framework integrations
@@ -9480,7 +9431,7 @@ async function main(command, args, flags, hippoRoot) {
                 console.error('Please provide a search query.');
                 process.exit(1);
             }
-            await cmdRecall(hippoRoot, query, flags);
+            await cmdRecall(hookStoreRoot(hippoRoot), query, flags);
             break;
         }
         case 'drill': {
@@ -9565,13 +9516,25 @@ async function main(command, args, flags, hippoRoot) {
             break;
         }
         case 'post-compact': {
-            // PostCompact hook: tells the user what pre-compact saved. Plain text,
-            // because Claude Code shows this hook's stdout as-is. Always exits 0.
+            // PostCompact hook: saves the compaction summary and its memories, then prints one plain line, because Claude Code shows this hook's stdout as-is. Always exits 0.
             const { text } = await readStdinBounded();
             const logFlag = flags['log-file'];
-            const message = postCompactMessage(text, logFlag === true || logFlag === false || Array.isArray(logFlag) ? undefined : logFlag);
-            if (message !== null)
-                console.log(message);
+            const store = hookStoreRoot(hippoRoot);
+            const line = cmdPostCompact(store, {
+                stdinText: text,
+                logFile: logFlag === true || logFlag === false || Array.isArray(logFlag) ? undefined : logFlag,
+                // Passed in, since capture.ts importing the sync would close an import cycle.
+                afterSave: (transcriptPath, originProject, log) => {
+                    const report = importAtCompaction(store, transcriptPath, originProject, { machine: currentMachine(), busyWaitMs: COMPACTION_DB_WAIT_MS });
+                    const summary = summaryLine(report);
+                    if (summary !== null)
+                        log(summary);
+                    for (const warning of report.warnings)
+                        log(`agent memories: ${warning}`);
+                },
+            });
+            if (line !== null)
+                console.log(line);
             break;
         }
         case 'capture-error': {
@@ -9631,7 +9594,7 @@ async function main(command, args, flags, hippoRoot) {
             }
             requireInit(hippoRoot);
             const entries = loadAllEntries(hippoRoot, resolveTenantId({}));
-            const result = auditMemories(entries);
+            const result = auditMemories(entries, memoriesBackingObjects(hippoRoot));
             const shouldFix = Boolean(flags['fix']);
             if (result.issues.length === 0) {
                 console.log(`All ${result.total} memories passed quality checks.`);
@@ -9869,7 +9832,7 @@ async function main(command, args, flags, hippoRoot) {
             // Bounded, not a TTY guard (DF1 T2, docs/plans/2026-08-23-df1-snapshot-lifecycle.md):
             // the hot stdin path and a manual run share this one command.
             const { text: stdinText } = await readStdinBounded();
-            await cmdContext(hippoRoot, args, flags, stdinText);
+            await cmdContext(hookStoreRoot(hippoRoot), args, flags, stdinText);
             break;
         }
         case 'hook':

package/dist/compaction-items.d.ts

@@ -0,0 +1,18 @@
+export declare const COMPACTION_ITEM_MAX_CHARS = 500;
+export declare const COMPACTION_ITEM_ROW_CAP = 10;
+export interface ParsedCompactionItems {
+    found: boolean;
+    items: string[];
+}
+export interface CompactionItemRows {
+    rows: string[];
+    tooLong: number;
+    capped: number;
+}
+/** The <summary> body of a PostCompact compact_summary with any <analysis> block removed; the whole text trimmed when there is no <summary> tag. */
+export declare function compactSummaryBody(compactSummary: string): string;
+/** found=false when no "Memories for hippo" heading; items in order, "none" dropped, never cut. */
+export declare function parseCompactionItems(summaryBody: string): ParsedCompactionItems;
+/** First COMPACTION_ITEM_ROW_CAP items of at most COMPACTION_ITEM_MAX_CHARS chars become rows. */
+export declare function selectItemRows(items: readonly string[]): CompactionItemRows;
+//# sourceMappingURL=compaction-items.d.ts.map

package/dist/compaction-items.js

@@ -0,0 +1,60 @@
+// Reads the "Memories for hippo" list out of a compaction summary. Pure text in, text out: hooks and replay share it.
+export const COMPACTION_ITEM_MAX_CHARS = 500;
+export const COMPACTION_ITEM_ROW_CAP = 10;
+const HEADING = 'memories for hippo';
+const ITEM_LINE = /^\s*(?:[-*]|\d+[.)])(?:\s+(.*))?$/;
+/** The <summary> body of a PostCompact compact_summary with any <analysis> block removed; the whole text trimmed when there is no <summary> tag. */
+export function compactSummaryBody(compactSummary) {
+    const text = compactSummary.replace(/<analysis>[\s\S]*?<\/analysis>/g, '');
+    const open = text.lastIndexOf('<summary>');
+    if (open < 0)
+        return text.trim();
+    const from = open + '<summary>'.length;
+    const close = text.indexOf('</summary>', from);
+    return text.slice(from, close < 0 ? undefined : close).trim();
+}
+function isHeading(line) {
+    const bare = line.replace(/^(?:[#*\s]|\d+\.)+/, '').replace(/[*:\s]+$/, '');
+    return bare.toLowerCase() === HEADING;
+}
+/** found=false when no "Memories for hippo" heading; items in order, "none" dropped, never cut. */
+export function parseCompactionItems(summaryBody) {
+    const lines = summaryBody.split(/\r?\n/);
+    let heading = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (isHeading(lines[i])) {
+            heading = i;
+            break;
+        }
+    }
+    if (heading < 0)
+        return { found: false, items: [] };
+    const after = lines.slice(heading + 1).join('\n');
+    const end = after.indexOf('</summary>');
+    const items = [];
+    let current = -1;
+    for (const line of (end < 0 ? after : after.slice(0, end)).split('\n')) {
+        if (line.trim() === '')
+            continue;
+        const marker = ITEM_LINE.exec(line);
+        if (marker) {
+            const text = (marker[1] ?? '').trim();
+            current = text === '' ? -1 : items.push(text) - 1;
+        }
+        else if (/^\s/.test(line)) {
+            if (current >= 0)
+                items[current] += ` ${line.trim()}`;
+        }
+        else {
+            break;
+        }
+    }
+    return { found: true, items: items.filter((item) => !/^none\.?$/i.test(item)) };
+}
+/** First COMPACTION_ITEM_ROW_CAP items of at most COMPACTION_ITEM_MAX_CHARS chars become rows. */
+export function selectItemRows(items) {
+    const fitting = items.filter((item) => item.length <= COMPACTION_ITEM_MAX_CHARS);
+    const rows = fitting.slice(0, COMPACTION_ITEM_ROW_CAP);
+    return { rows, tooLong: items.length - fitting.length, capped: fitting.length - rows.length };
+}
+//# sourceMappingURL=compaction-items.js.map