hippo-memory 1.52.6 → 1.52.7

package/dist/cli.js

@@ -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']) {
@@ -546,57 +554,86 @@ function cmdInit(hippoRoot, flags) {
         }
     }
 }
-/**
- * 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
@@ -877,6 +914,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
@@ -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}`);
@@ -2628,6 +2667,7 @@ export function learnFromMemoryMd(hippoRoot, homeDir = os.homedir()) {
     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 +2711,7 @@ export function learnFromMemoryMd(hippoRoot, homeDir = os.homedir()) {
                     source: `claude-memory:${file}`,
                     confidence: 'observed',
                     tenantId: resolveTenantId({}),
+                    baseHalfLifeDays,
                 });
                 try {
                     writeEntry(hippoRoot, entry);
@@ -6839,7 +6880,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 +6947,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 +7223,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 +7245,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 +7294,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 +7318,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 +7329,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 +7347,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 +7406,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 +7497,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 +7532,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, '\\$&');
 }

package/dist/config.js

@@ -151,8 +151,15 @@ export function loadConfig(hippoRoot) {
                 `(got ${JSON.stringify(churnStalenessEnabled)}) - using false.`);
             churnStalenessEnabled = false;
         }
+        // Every writer starts a memory on this, and a zero or negative half-life scores zero strength, so sleep would retire it.
+        let defaultHalfLifeDays = raw.defaultHalfLifeDays ?? DEFAULT_CONFIG.defaultHalfLifeDays;
+        if (!Number.isFinite(defaultHalfLifeDays) || defaultHalfLifeDays <= 0) {
+            console.error(`Warning: config.json's "defaultHalfLifeDays" must be a number of days above 0 ` +
+                `(got ${JSON.stringify(defaultHalfLifeDays)}) - using ${DEFAULT_CONFIG.defaultHalfLifeDays}.`);
+            defaultHalfLifeDays = DEFAULT_CONFIG.defaultHalfLifeDays;
+        }
         return {
-            defaultHalfLifeDays: raw.defaultHalfLifeDays ?? DEFAULT_CONFIG.defaultHalfLifeDays,
+            defaultHalfLifeDays,
             defaultBudget: raw.defaultBudget ?? DEFAULT_CONFIG.defaultBudget,
             defaultContextBudget: raw.defaultContextBudget ?? DEFAULT_CONFIG.defaultContextBudget,
             decayBasis: validBasis ? basis : DEFAULT_CONFIG.decayBasis,

package/dist/consolidate.d.ts

@@ -37,6 +37,8 @@ export interface ConsolidationResult {
     /** Ids the decay pass removes (or would remove, under dryRun). */
     removedIds?: string[];
 }
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
+export declare const MEMORY_BACKED_TABLES: readonly ["predictions", "decisions", "incidents", "processes", "policies", "skills", "project_briefs", "customer_notes"];
 /**
  * Run a full consolidation pass.
  */

package/dist/consolidate.js

@@ -24,7 +24,7 @@ import { resolveTenantId } from './tenant.js';
 import { rescueSet, rankNonPinnedByTenant, validateWeights } from './memory-value.js';
 import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from './memory-value-weights.js';
 import { appendAuditEvent } from './audit.js';
-import { migrateDefaultHalfLife } from './half-life-migration.js';
+import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from './half-life-migration.js';
 import { derivationScope, commonDerivationScope, derivationPartitionKey } from './recall-scope.js';
 import { isQuarantineScope } from './quarantine.js';
 const DECAY_THRESHOLD = 0.05;
@@ -64,10 +64,10 @@ const REPLAY_COUNT_DEFAULT = 5;
 function isJsonString(value) {
     return typeof value === 'string';
 }
-/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL). */
-const MEMORY_BACKED_TABLES = ['predictions', 'decisions', 'processes', 'policies', 'skills', 'project_briefs', 'customer_notes'];
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
+export const MEMORY_BACKED_TABLES = ['predictions', 'decisions', 'incidents', 'processes', 'policies', 'skills', 'project_briefs', 'customer_notes'];
 /**
- * Ids of memories that back a first-class object (a decision, prediction,
+ * Ids of memories that back a first-class object (a decision, incident, prediction,
  * process, policy, skill, project brief or customer note). Sleep never
  * retires these: deleting or moving one to dormant storage fires the
  * object's ON DELETE SET NULL and a restore cannot repair the link. Their
@@ -85,8 +85,10 @@ function memoriesBackingObjects(hippoRoot) {
                 for (const r of rows)
                     ids.add(r.memory_id);
             }
-            catch {
-                // Table not present in this schema version.
+            catch (err) {
+                // A missing table is an older schema; any other error could hide a backing memory, so sleep stops.
+                if (!(err instanceof Error && err.message.includes('no such table')))
+                    throw err;
             }
         }
     }
@@ -131,6 +133,9 @@ export async function consolidate(hippoRoot, options = {}) {
     if (halfLife.rescaled > 0) {
         result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.rescaled} memories from the ${halfLife.from}-day to the ${halfLife.to}-day half-life`);
     }
+    if (halfLife.typed > 0) {
+        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.typed} memories of decisions, incidents and other objects from the ${LEGACY_TYPED_HALF_LIFE}-day to the ${halfLife.to}-day half-life`);
+    }
     // L9: host-wide by design. Consolidation runs across all tenants in one
     // pass — per-tenant filtering would create N consolidation runs per host
     // with no cross-tenant dedup. The api.sleep audit row tags this with the
@@ -410,6 +415,7 @@ export async function consolidate(hippoRoot, options = {}) {
                     // consolidationTenant — for any non-default tenant that check never
                     // hit, and the trace regenerated every sleep.
                     tenantId: consolidationTenant,
+                    baseHalfLifeDays: config.defaultHalfLifeDays,
                 });
                 // AT1 (same producer-side pattern as the merge pass below): traceExistsForSession
                 // only sees rows CURRENTLY in the store — once a rejected trace is
@@ -737,6 +743,7 @@ export async function consolidate(hippoRoot, options = {}) {
                         confidence: 'inferred',
                         tenantId: mergeTenant,
                         scope: mergeScope,
+                        baseHalfLifeDays: config.defaultHalfLifeDays,
                     });
                 }
                 // mergeContents is DETERMINISTIC CONCATENATION (not an LLM paraphrase)

package/dist/customer-notes.js

@@ -22,8 +22,9 @@
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
 import { markGraphDirty, removeGraphEntitiesForObject } from './graph.js';
-import { createMemory, Layer, CUSTOMER_NOTE_HALF_LIFE_DAYS } from './memory.js';
+import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
+import { objectHalfLifeDays } from './half-life-migration.js';
 export const VALID_NOTE_STATES = new Set([
     'active',
     'superseded',
@@ -118,9 +119,9 @@ export function saveCustomerNote(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'customer_note',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = CUSTOMER_NOTE_HALF_LIFE_DAYS;
     let savedRow;
     writeEntry(hippoRoot, mem, {
         actor,

package/dist/dag.js

@@ -3,6 +3,7 @@ import { writeEntry, loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildR
 import { RejectedValueError } from './rejection.js';
 import { redactSecrets } from './secret-detect.js';
 import { derivationScope, derivationPartitionKey } from './recall-scope.js';
+import { loadConfig } from './config.js';
 export function clusterFacts(facts) {
     if (facts.length === 0)
         return [];
@@ -84,6 +85,7 @@ export async function generateDagSummary(label, factContents, opts) {
 }
 export async function buildDag(hippoRoot, facts, opts) {
     const result = { candidateClusters: 0, summariesCreated: 0, factsLinked: 0, rejected: 0 };
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
     const unparented = facts.filter((f) => f.dag_level === 1 && !f.dag_parent_id && f.tags.includes('extracted'));
     // Hardening follow-up (mirrors consolidate.ts's mergeCandidatesByTenant,
     // T1): partition unparented facts by tenantId BEFORE clustering so a
@@ -123,6 +125,7 @@ export async function buildDag(hippoRoot, facts, opts) {
                 dag_level: 2,
                 tenantId: factTenant,
                 scope: factScope,
+                baseHalfLifeDays,
             });
             // Schema v25: cache descendant_count + earliest/latest_at on the summary
             // row so DAG-aware recall (docs/plans/2026-05-05-dag-recall.md Task 2)
@@ -293,6 +296,7 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
         failed: 0,
         rejected: 0,
     };
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
     // Only L2 with no L3 parent yet (avoid re-clustering already-profiled L2s).
     const unparented = l2Summaries.filter((s) => s.dag_level === 2 && !s.dag_parent_id);
     // independent-review HIGH #1 fold: cluster ONLY within-tenant.
@@ -330,6 +334,7 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
                 dag_level: 3,
                 tenantId, // HIGH #1 fold: thread tenant explicitly
                 scope,
+                baseHalfLifeDays,
             });
             profileEntry.descendant_count = cluster.members.length;
             profileEntry.earliest_at = memberCreatedAts[0];

package/dist/decisions.d.ts

@@ -64,7 +64,7 @@ export interface ListDecisionsOpts {
  *
  * The memory mirror preserves the legacy `hippo decide` shape: tags
  * ['decision', ...extraTags], source 'decision', confidence 'verified',
- * half_life DECISION_HALF_LIFE_DAYS, content = "<text>\n\nContext: <context>"
+ * the half-life objectHalfLifeDays picks, content = "<text>\n\nContext: <context>"
  * when context is given (so existing recall output is unchanged).
  */
 export declare function saveDecision(hippoRoot: string, tenantId: string, opts: SaveDecisionOpts, actor?: string): Decision;

package/dist/decisions.js

@@ -26,8 +26,9 @@
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
 import { markGraphDirty, removeGraphEntitiesForObject } from './graph.js';
-import { createMemory, Layer, DECISION_HALF_LIFE_DAYS } from './memory.js';
+import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
+import { objectHalfLifeDays } from './half-life-migration.js';
 export const VALID_DECISION_STATES = new Set([
     'active',
     'superseded',
@@ -65,7 +66,7 @@ const DECISION_COLS = `
  *
  * The memory mirror preserves the legacy `hippo decide` shape: tags
  * ['decision', ...extraTags], source 'decision', confidence 'verified',
- * half_life DECISION_HALF_LIFE_DAYS, content = "<text>\n\nContext: <context>"
+ * the half-life objectHalfLifeDays picks, content = "<text>\n\nContext: <context>"
  * when context is given (so existing recall output is unchanged).
  */
 export function saveDecision(hippoRoot, tenantId, opts, actor = 'cli') {
@@ -82,9 +83,9 @@ export function saveDecision(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'decision',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = DECISION_HALF_LIFE_DAYS;
     // Populated inside afterWrite so the INSERT, the supersede UPDATE, and the
     // memory write all share one SAVEPOINT.
     let savedRow;