hippo-memory 1.52.5 → 1.52.7

package/dist/extract.js

@@ -1,5 +1,6 @@
 import { Layer, createMemory } from './memory.js';
 import { writeEntry } from './store.js';
+import { loadConfig } from './config.js';
 import { RejectedValueError } from './rejection.js';
 import { redactSecrets } from './secret-detect.js';
 function isJsonString(value) {
@@ -83,6 +84,7 @@ export function storeExtractedFacts(hippoRoot, source, facts) {
     const inheritedTags = source.tags.filter((t) => INHERITABLE_PREFIXES.some((p) => t.startsWith(p)));
     const entries = [];
     let rejected = 0;
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
     for (const fact of facts) {
         const tags = ['extracted', ...inheritedTags, ...fact.tags];
         const entry = createMemory(fact.content, {
@@ -99,6 +101,7 @@ export function storeExtractedFacts(hippoRoot, source, facts) {
             // entry's own tenant. Thread it through so extracted facts land in
             // the same tenant as the episodic memory they were extracted from.
             tenantId: source.tenantId,
+            baseHalfLifeDays,
         });
         // AT1 containment: a refusal is per-VALUE — one rejected fact must not
         // drop the rest of this batch. writeEntry has already audited the

package/dist/half-life-migration.d.ts

@@ -17,12 +17,15 @@
  *   migration runs once.
  *
  * `hippo sleep` runs it before its decay pass, from the base the store is on
- * (7 days when never recorded) to the configured `defaultHalfLifeDays`.
+ * (7 days when never recorded) to the configured `defaultHalfLifeDays`. Once per store it also
+ * moves memories of live decisions, incidents and other objects off the flat 90 days they used to get.
  */
 import { type MemoryEntry } from './memory.js';
 import { HALF_LIFE_BASE_META_KEY } from './store.js';
 /** The base every store used before the base was recorded. */
 export declare const LEGACY_HALF_LIFE_BASE = 7;
+/** The flat half-life the decision, incident and other object writers gave their memories before they took the default. */
+export declare const LEGACY_TYPED_HALF_LIFE = 90;
 export { HALF_LIFE_BASE_META_KEY };
 /** What {@link migrateDefaultHalfLife} did, or would do under `dryRun`. */
 export interface HalfLifeMigrationResult {
@@ -30,6 +33,8 @@ export interface HalfLifeMigrationResult {
     to: number;
     /** Memories moved to the new base. */
     rescaled: number;
+    /** Memories of decisions, incidents and other objects moved off the flat 90 days. */
+    typed: number;
     /** Memories left alone because they are not on the old base. */
     kept: number;
     dryRun: boolean;
@@ -37,15 +42,19 @@ export interface HalfLifeMigrationResult {
     halfLives: ReadonlyMap<string, number>;
 }
 type HalfLifeFields = Pick<MemoryEntry, 'half_life_days' | 'tags' | 'schema_fit' | 'retrieval_count' | 'superseded_by'>;
-/** Recall bonus over what `base` gave `entry`, or null when off that base; pre-1.46 recalls each added 2 days. */
-export declare function halfLifeRecallBonus(entry: HalfLifeFields, base: number): number | null;
+/** Recall bonus over `written`, the half-life `entry` got at write, or null when off it; each recall added 2 days. */
+export declare function halfLifeRecallBonus(entry: HalfLifeFields, written: number): number | null;
 /** The entries to rescale from `from` to `to`, as copies that keep their recall bonus. Pure. */
 export declare function planHalfLifeMigration(entries: readonly MemoryEntry[], from: number, to: number): MemoryEntry[];
+/** Memories of decisions, incidents and other objects still on the flat 90 days, as copies on `to` that keep their recall bonus. Pure. */
+export declare function planTypedHalfLifeMigration(entries: readonly MemoryEntry[], to: number): MemoryEntry[];
 /** The base this store's memories are on. */
 export declare function storeHalfLifeBase(hippoRoot: string): number;
+/** The base an object writer gives its memory: the flat 90 days until this store's typed migration has run, which then moves them, and the default after. */
+export declare function objectHalfLifeDays(hippoRoot: string): number;
 /**
- * Move the store's memories from the base they are on to `to`. A no-op when
- * they are already on it. Under `dryRun` nothing is written, the recorded
+ * Move the store's memories from the base they are on, and those of objects from
+ * the old flat 90 days, to `to`, once. Under `dryRun` nothing is written, the recorded
  * base included.
  */
 export declare function migrateDefaultHalfLife(hippoRoot: string, to: number, opts?: {

package/dist/half-life-migration.js

@@ -17,20 +17,26 @@
  *   migration runs once.
  *
  * `hippo sleep` runs it before its decay pass, from the base the store is on
- * (7 days when never recorded) to the configured `defaultHalfLifeDays`.
+ * (7 days when never recorded) to the configured `defaultHalfLifeDays`. Once per store it also
+ * moves memories of live decisions, incidents and other objects off the flat 90 days they used to get.
  */
 import { deriveHalfLife } from './memory.js';
-import { openStore, selectAllEntries, HALF_LIFE_BASE_META_KEY } from './store.js';
+import { openStore, selectAllEntries, HALF_LIFE_BASE_META_KEY, TYPED_HALF_LIFE_META_KEY } from './store.js';
 import { openHippoDb, closeHippoDb, getMeta, setMeta } from './db.js';
 import { appendAuditEvent } from './audit.js';
+import { loadConfig } from './config.js';
 /** The base every store used before the base was recorded. */
 export const LEGACY_HALF_LIFE_BASE = 7;
+/** The flat half-life the decision, incident and other object writers gave their memories before they took the default. */
+export const LEGACY_TYPED_HALF_LIFE = 90;
+const TYPED_SOURCES = new Set(['decision', 'incident', 'process', 'policy', 'skill', 'project_brief', 'customer_note']);
+const OBJECT_TABLES = ['decisions', 'incidents', 'processes', 'policies', 'skills', 'project_briefs', 'customer_notes'];
 export { HALF_LIFE_BASE_META_KEY };
-/** Recall bonus over what `base` gave `entry`, or null when off that base; pre-1.46 recalls each added 2 days. */
-export function halfLifeRecallBonus(entry, base) {
+/** Recall bonus over `written`, the half-life `entry` got at write, or null when off it; each recall added 2 days. */
+export function halfLifeRecallBonus(entry, written) {
     if (entry.superseded_by || entry.tags.includes('invalidated') || entry.tags.includes('superseded'))
         return null;
-    const bonus = entry.half_life_days - deriveHalfLife(base, entry);
+    const bonus = entry.half_life_days - written;
     const k = Math.round(bonus / 2);
     return Math.abs(bonus - 2 * k) < 1e-9 && k >= 0 && k <= entry.retrieval_count ? bonus : null;
 }
@@ -39,10 +45,18 @@ export function planHalfLifeMigration(entries, from, to) {
     if (from === to)
         return [];
     return entries.flatMap((e) => {
-        const bonus = halfLifeRecallBonus(e, from);
+        const bonus = halfLifeRecallBonus(e, deriveHalfLife(from, e));
         return bonus === null ? [] : [{ ...e, half_life_days: deriveHalfLife(to, e) + bonus }];
     });
 }
+/** Memories of decisions, incidents and other objects still on the flat 90 days, as copies on `to` that keep their recall bonus. Pure. */
+export function planTypedHalfLifeMigration(entries, to) {
+    return entries.flatMap((e) => {
+        const bonus = TYPED_SOURCES.has(e.source) ? halfLifeRecallBonus(e, LEGACY_TYPED_HALF_LIFE) : null;
+        const next = bonus === null ? e.half_life_days : deriveHalfLife(to, e) + bonus;
+        return next === e.half_life_days ? [] : [{ ...e, half_life_days: next }];
+    });
+}
 /** The base this store's memories are on. */
 export function storeHalfLifeBase(hippoRoot) {
     const db = openHippoDb(hippoRoot);
@@ -57,14 +71,25 @@ function readBase(db) {
     const raw = Number(getMeta(db, HALF_LIFE_BASE_META_KEY, String(LEGACY_HALF_LIFE_BASE)));
     return Number.isFinite(raw) && raw > 0 ? raw : LEGACY_HALF_LIFE_BASE;
 }
+/** The base an object writer gives its memory: the flat 90 days until this store's typed migration has run, which then moves them, and the default after. */
+export function objectHalfLifeDays(hippoRoot) {
+    // SHORTCUT: read outside the write's transaction, so a write racing the typed migration keeps 90; read inside writeEntry if that ever matters.
+    const db = openStore(hippoRoot);
+    try {
+        return getMeta(db, TYPED_HALF_LIFE_META_KEY, '') === '' ? LEGACY_TYPED_HALF_LIFE : loadConfig(hippoRoot).defaultHalfLifeDays;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
 /**
- * Move the store's memories from the base they are on to `to`. A no-op when
- * they are already on it. Under `dryRun` nothing is written, the recorded
+ * Move the store's memories from the base they are on, and those of objects from
+ * the old flat 90 days, to `to`, once. Under `dryRun` nothing is written, the recorded
  * base included.
  */
 export function migrateDefaultHalfLife(hippoRoot, to, opts = {}) {
     const dryRun = opts.dryRun ?? false;
-    const noop = (from) => ({ from, to, rescaled: 0, kept: 0, dryRun, halfLives: new Map() });
+    const noop = (from) => ({ from, to, rescaled: 0, typed: 0, kept: 0, dryRun, halfLives: new Map() });
     const db = openStore(hippoRoot);
     try {
         // Plan, write, audit and record the base under one write lock, so a concurrent write or sleep cannot interleave.
@@ -72,28 +97,31 @@ export function migrateDefaultHalfLife(hippoRoot, to, opts = {}) {
             db.exec('BEGIN IMMEDIATE');
         try {
             const from = readBase(db);
-            if (!(Number.isFinite(to) && to > 0) || from === to) {
+            const typedPending = getMeta(db, TYPED_HALF_LIFE_META_KEY, '') === '';
+            if (!(Number.isFinite(to) && to > 0) || (from === to && !typedPending)) {
                 if (!dryRun)
                     db.exec('COMMIT');
                 return noop(from);
             }
             const all = selectAllEntries(db);
-            const plan = planHalfLifeMigration(all, from, to);
+            const objects = typedPending ? objectMemoryIds(db) : { all: new Set(), retired: new Set() };
+            const losers = typedPending ? conflictLosers(db) : new Set();
+            const copies = new Set(all.flatMap((e) => (e.superseded_by ? [e.superseded_by] : [])));
+            // Provenance before shape: an object's memory came from its writer, a supersede copy from the base (it keeps the source). Shape decides the rest.
+            const objectWritten = (e) => objects.all.has(e.id) || (!copies.has(e.id) && TYPED_SOURCES.has(e.source) && halfLifeRecallBonus(e, LEGACY_TYPED_HALF_LIFE) !== null);
+            const typedPlan = typedPending ? planTypedHalfLifeMigration(all.filter((e) => objectWritten(e) && !objects.retired.has(e.id) && !losers.has(e.id)), to) : [];
+            const basePlan = planHalfLifeMigration(typedPending ? all.filter((e) => !objectWritten(e)) : all, from, to);
+            const plan = [...basePlan, ...typedPlan];
             const halfLives = new Map(plan.map((e) => [e.id, e.half_life_days]));
-            const result = { from, to, rescaled: plan.length, kept: all.length - plan.length, dryRun, halfLives };
+            const result = { from, to, rescaled: basePlan.length, typed: typedPlan.length, kept: all.length - plan.length, dryRun, halfLives };
             if (dryRun)
                 return result;
             const old = new Map(all.map((e) => [e.id, e.half_life_days]));
-            const update = db.prepare('UPDATE memories SET half_life_days = ? WHERE id = ?');
-            const byTenant = new Map();
-            for (const e of plan) {
-                update.run(e.half_life_days, e.id);
-                byTenant.set(e.tenantId, { ...byTenant.get(e.tenantId), [e.id]: old.get(e.id) });
-            }
-            for (const [tenantId, oldHalfLives] of byTenant) {
-                appendAuditEvent(db, { tenantId, actor: opts.actor ?? 'system', op: 'half_life_migrate', metadata: { from, to, ids: Object.keys(oldHalfLives), oldHalfLives } });
-            }
+            const actor = opts.actor ?? 'system';
+            writePlan(db, basePlan, old, { from, to, actor });
+            writePlan(db, typedPlan, old, { from: LEGACY_TYPED_HALF_LIFE, to, actor });
             setMeta(db, HALF_LIFE_BASE_META_KEY, String(to));
+            setMeta(db, TYPED_HALF_LIFE_META_KEY, '1');
             db.exec('COMMIT');
             return result;
         }
@@ -107,4 +135,44 @@ export function migrateDefaultHalfLife(hippoRoot, to, opts = {}) {
         closeHippoDb(db);
     }
 }
+/** Memories behind every object, and those behind a superseded or closed one. Retiring an object leaves its memory untouched, so only its table knows. */
+function objectMemoryIds(db) {
+    const all = new Set();
+    const retired = new Set();
+    for (const table of OBJECT_TABLES) {
+        // SAFETY: SELECT of two TEXT columns, filtered to a non-null memory_id.
+        const rows = db.prepare(`SELECT memory_id, status FROM ${table} WHERE memory_id IS NOT NULL`).all();
+        for (const r of rows) {
+            all.add(r.memory_id);
+            if (r.status === 'superseded' || r.status === 'closed')
+                retired.add(r.memory_id);
+        }
+    }
+    return { all, retired };
+}
+/** Memories that lost a conflict, which resolveConflict halved untagged. A resolved conflict with no audit row (before v1.31.0, or found stale) names no winner, so both sides count. */
+function conflictLosers(db) {
+    // SAFETY: SELECT of two fields every conflict_resolve audit row carries (ConflictResolveMeta in store.ts).
+    const audited = db.prepare(`SELECT json_extract(metadata_json, '$.conflictId') AS conflictId, json_extract(metadata_json, '$.loserId') AS loserId FROM audit_log WHERE op = 'conflict_resolve'`).all();
+    const losers = new Set(audited.map((a) => a.loserId));
+    const named = new Set(audited.map((a) => a.conflictId));
+    // SAFETY: SELECT of three columns of resolved conflicts.
+    const resolved = db.prepare(`SELECT id, memory_a_id, memory_b_id FROM memory_conflicts WHERE status = 'resolved'`).all();
+    for (const c of resolved)
+        if (!named.has(c.id))
+            losers.add(c.memory_a_id).add(c.memory_b_id);
+    return losers;
+}
+/** Writes `plan`, then one audit event per tenant with each id's old half-life, so the move can be undone. */
+function writePlan(db, plan, old, move) {
+    const update = db.prepare('UPDATE memories SET half_life_days = ? WHERE id = ?');
+    const byTenant = new Map();
+    for (const e of plan) {
+        update.run(e.half_life_days, e.id);
+        byTenant.set(e.tenantId, { ...byTenant.get(e.tenantId), [e.id]: old.get(e.id) });
+    }
+    for (const [tenantId, oldHalfLives] of byTenant) {
+        appendAuditEvent(db, { tenantId, actor: move.actor, op: 'half_life_migrate', metadata: { from: move.from, to: move.to, ids: Object.keys(oldHalfLives), oldHalfLives } });
+    }
+}
 //# sourceMappingURL=half-life-migration.js.map

package/dist/hooks.js

@@ -966,7 +966,7 @@ export function detectInstalledTools() {
         { name: 'opencode', configDir: '~/.config/opencode', detected: exists('.config', 'opencode'), kind: 'plugin', notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts' },
         { name: 'openclaw', configDir: '~/.openclaw', detected: exists('.openclaw'), kind: 'plugin', notes: 'install via `openclaw plugins install hippo-memory`' },
         { name: 'codex', configDir: '~/.codex', detected: exists('.codex'), kind: 'wrapper', notes: 'wraps the detected codex launcher for session-end consolidation' },
-        { name: 'cursor', configDir: '~/.cursor', detected: exists('.cursor'), kind: 'markdown-instruction', notes: 'no hook API - patches .cursorrules in the project' },
+        { name: 'cursor', configDir: '~/.cursor', detected: exists('.cursor'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
         { name: 'pi', configDir: '~/.pi', detected: exists('.pi'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
     ];
 }

package/dist/importers.d.ts

@@ -58,7 +58,8 @@ export interface ImportOptions {
 export declare function importEntries(chunks: string[], source: string, tags: string[], options: ImportOptions): ImportResult;
 export declare function importChatGPT(filePath: string, options: ImportOptions): ImportResult;
 export declare function importClaude(filePath: string, options: ImportOptions): ImportResult;
-export declare function importCursor(filePath: string, options: ImportOptions): ImportResult;
+/** Import `.cursorrules`, one rule file, or a `.cursor/rules` tree of `.mdc` and `.md` rules. */
+export declare function importCursor(sourcePath: string, options: ImportOptions): ImportResult;
 export declare function importGenericFile(filePath: string, options: ImportOptions): ImportResult;
 export declare function importMarkdown(filePath: string, options: ImportOptions): ImportResult;
 /**

package/dist/importers.js

@@ -12,6 +12,7 @@ import { getGlobalRoot, initGlobal } from './shared.js';
 import { remember, archiveRaw, isPrivateScope } from './api.js';
 import { openHippoDb, closeHippoDb } from './db.js';
 import { RejectedValueError, checkRejectionGuard } from './rejection.js';
+import { loadConfig } from './config.js';
 // ---------------------------------------------------------------------------
 // Shared core: dedup + write
 // ---------------------------------------------------------------------------
@@ -27,6 +28,7 @@ export function importEntries(chunks, source, tags, options) {
     }
     const existing = loadAllEntries(targetRoot, options.global ? undefined : options.tenantId);
     const allTags = [...new Set([...tags, ...(options.extraTags ?? [])])];
+    const baseHalfLifeDays = loadConfig(targetRoot).defaultHalfLifeDays;
     let total = 0;
     let imported = 0;
     let skipped = 0;
@@ -80,6 +82,7 @@ export function importEntries(chunks, source, tags, options) {
                 source,
                 confidence: 'observed',
                 tenantId: options.global ? undefined : options.tenantId,
+                baseHalfLifeDays,
             });
             if (options.dryRun) {
                 if (dryRunDb) {
@@ -314,9 +317,16 @@ function parseCursorFile(content) {
         return parts.map((p) => p.trim()).filter(Boolean);
     });
 }
-export function importCursor(filePath, options) {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    const chunks = parseCursorFile(raw);
+const CURSOR_RULE_FILE = /\.mdc?$/i;
+/** Import `.cursorrules`, one rule file, or a `.cursor/rules` tree of `.mdc` and `.md` rules. */
+export function importCursor(sourcePath, options) {
+    const files = fs.statSync(sourcePath).isDirectory()
+        ? collectMarkdownFiles(sourcePath, options.hippoRoot, CURSOR_RULE_FILE).map((rel) => path.join(sourcePath, rel))
+        : [sourcePath];
+    const chunks = files.flatMap((file) => {
+        const raw = fs.readFileSync(file, 'utf8');
+        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? parseFrontmatter(raw).body : raw);
+    });
     return importEntries(chunks, 'import:cursor', ['imported', 'cursor'], options);
 }
 // ---------------------------------------------------------------------------
@@ -521,8 +531,8 @@ function parseWikilinks(body) {
     }
     return out;
 }
-/** Recursively collect `*.md` files under `root`, returning paths relative to
- *  `root` with forward-slash separators (stable artifactRef keys across OSes).
+/** Recursively collect files whose name matches `match` (`*.md` by default) under `root`,
+ *  as paths relative to `root` with forward-slash separators (stable artifactRef keys across OSes).
  *  Symlinks are not followed. Skips dot-directories (the default `.hippo` store,
  *  `.git`, `.obsidian`, `.trash`) AND the canonicalized Hippo store path during
  *  the walk, so re-importing a vault that CONTAINS the store never ingests its own
@@ -531,7 +541,7 @@ function parseWikilinks(body) {
  *  every run). The root-IS-the-store case is handled one level up in
  *  importVault (a no-op early return), NOT here: returning [] for it would feed
  *  the deletion-sync an empty scan that mass-archives every live row (codex R8). */
-function collectMarkdownFiles(root, hippoRoot) {
+function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     const out = [];
     // Canonicalize (realpath) so a non-dot HIPPO_HOME store nested in the vault is
     // skipped even when hippoRoot is an aliased path (junction / Windows case
@@ -553,7 +563,7 @@ function collectMarkdownFiles(root, hippoRoot) {
                     continue;
                 walk(abs);
             }
-            else if (ent.isFile() && ent.name.toLowerCase().endsWith('.md')) {
+            else if (ent.isFile() && match.test(ent.name)) {
                 out.push(path.relative(root, abs).split(path.sep).join('/'));
             }
         }
@@ -693,6 +703,7 @@ export function importVault(folderPath, options) {
     let rejected = 0;
     let archived = 0;
     const entries = [];
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
     // AT1 P2 fix: dry-run never called remember(), so it never probed
     // tombstones — every note that reached the write step counted as
     // `imported` even when a real run would refuse it. Probe (read-only) via
@@ -799,6 +810,7 @@ export function importVault(folderPath, options) {
                 owner: 'agent:vault-import',
                 artifact_ref: artifactRef,
                 tenantId,
+                baseHalfLifeDays,
             });
             // dryRun preview: count what WOULD import, but make no writes (codex P2).
             if (!dryRun) {

package/dist/incidents.d.ts

@@ -63,7 +63,7 @@ export interface ListIncidentsOpts {
  * inside writeEntry's SAVEPOINT 'write_entry'.
  *
  * The memory mirror: tags ['incident', ...extraTags], source 'incident',
- * confidence 'verified', half_life INCIDENT_HALF_LIFE_DAYS, content =
+ * confidence 'verified', the half-life objectHalfLifeDays picks, content =
  * "<text>\n\nContext: <context>" when context is given.
  *
  * linked_memory_ids are validated BEFORE insert: each must exist in the SAME

package/dist/incidents.js

@@ -27,8 +27,9 @@
  */
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
-import { createMemory, Layer, INCIDENT_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_INCIDENT_STATES = new Set([
     'open',
     'resolved',
@@ -77,7 +78,7 @@ const INCIDENT_COLS = `
  * inside writeEntry's SAVEPOINT 'write_entry'.
  *
  * The memory mirror: tags ['incident', ...extraTags], source 'incident',
- * confidence 'verified', half_life INCIDENT_HALF_LIFE_DAYS, content =
+ * confidence 'verified', the half-life objectHalfLifeDays picks, content =
  * "<text>\n\nContext: <context>" when context is given.
  *
  * linked_memory_ids are validated BEFORE insert: each must exist in the SAME
@@ -98,9 +99,9 @@ export function saveIncident(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'incident',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = INCIDENT_HALF_LIFE_DAYS;
     const linkInput = opts.linkedMemoryIds ?? [];
     // Populated inside afterWrite so the linked-id validation, the INSERT, and the
     // memory write all share one SAVEPOINT.

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 /**
  * Hippo public API  - re-exports for programmatic use.
  */
-export { MemoryEntry, Layer, EmotionalValence, ConfidenceLevel, DecayOptions, calculateStrength, resolveConfidence, confidenceFacets, type ConfidenceFacets, createMemory, applyOutcome, generateId, computeSchemaFit } from './memory.js';
+import { type CreateMemoryOptions, type MemoryEntry } from './memory.js';
+export { MemoryEntry, Layer, EmotionalValence, ConfidenceLevel, DecayOptions, calculateStrength, resolveConfidence, confidenceFacets, type ConfidenceFacets, applyOutcome, generateId, computeSchemaFit } from './memory.js';
+/** Published signature, so `baseHalfLifeDays` stays optional here; hippo's own writers use the strict one in memory.ts. */
+export declare function createMemory(content: string, options?: Partial<CreateMemoryOptions>): MemoryEntry;
 export { search, hybridSearch, physicsSearch, markRetrieved, estimateTokens, textOverlap, tokenize, explainMatch, detectTemporalDirection, temporalBoost, computeTemporalRange, SearchResult, MatchExplanation } from './search.js';
 export { multihopSearch } from './multihop.js';
 export { graphExpandRecall, MAX_HOPS, DEFAULT_MAX_NEIGHBORS, type GraphExpandOpts } from './graph-recall.js';

package/dist/index.js

@@ -1,7 +1,12 @@
 /**
  * Hippo public API  - re-exports for programmatic use.
  */
-export { Layer, calculateStrength, resolveConfidence, confidenceFacets, createMemory, applyOutcome, generateId, computeSchemaFit } from './memory.js';
+import { createMemory as createStoreMemory, DEFAULT_HALF_LIFE_DAYS } from './memory.js';
+export { Layer, calculateStrength, resolveConfidence, confidenceFacets, applyOutcome, generateId, computeSchemaFit } from './memory.js';
+/** Published signature, so `baseHalfLifeDays` stays optional here; hippo's own writers use the strict one in memory.ts. */
+export function createMemory(content, options = {}) {
+    return createStoreMemory(content, { ...options, baseHalfLifeDays: options.baseHalfLifeDays ?? DEFAULT_HALF_LIFE_DAYS });
+}
 export { search, hybridSearch, physicsSearch, markRetrieved, estimateTokens, textOverlap, tokenize, explainMatch, detectTemporalDirection, temporalBoost, computeTemporalRange } from './search.js';
 export { multihopSearch } from './multihop.js';
 export { graphExpandRecall, MAX_HOPS, DEFAULT_MAX_NEIGHBORS } from './graph-recall.js';

package/dist/memory.d.ts

@@ -113,13 +113,6 @@ export interface MemoryEntry {
      */
     bm25_score?: number;
 }
-export declare const DECISION_HALF_LIFE_DAYS = 90;
-export declare const INCIDENT_HALF_LIFE_DAYS = 90;
-export declare const PROCESS_HALF_LIFE_DAYS = 90;
-export declare const POLICY_HALF_LIFE_DAYS = 90;
-export declare const SKILL_HALF_LIFE_DAYS = 90;
-export declare const PROJECT_BRIEF_HALF_LIFE_DAYS = 90;
-export declare const CUSTOMER_NOTE_HALF_LIFE_DAYS = 90;
 /** FE2: tag on a memory whose named file/symbol/script changed after it was stored. */
 export declare const CHURN_STALE_TAG = "churn-stale";
 /**
@@ -222,10 +215,7 @@ export declare function resolveConfidence(entry: MemoryEntry, now?: Date): Confi
 export declare const DEFAULT_HALF_LIFE_DAYS = 365;
 export declare const AUTO_DELETABLE_SQL = "pinned = 0 AND kind != 'raw'";
 export declare function canAutoDelete(entry: Pick<MemoryEntry, 'pinned' | 'kind'>): boolean;
-/**
- * Create a new memory entry with defaults.
- */
-export declare function createMemory(content: string, options?: {
+export interface CreateMemoryOptions {
     layer?: Layer;
     tags?: string[];
     emotional_valence?: EmotionalValence;
@@ -233,7 +223,8 @@ export declare function createMemory(content: string, options?: {
     schema_fit?: number;
     source?: string;
     confidence?: ConfidenceLevel;
-    baseHalfLifeDays?: number;
+    /** The store's `loadConfig(hippoRoot).defaultHalfLifeDays`; required so no writer falls back to the compiled default by leaving it out. */
+    baseHalfLifeDays: number;
     trace_outcome?: TraceOutcome;
     source_session_id?: string | null;
     valid_from?: string;
@@ -245,7 +236,9 @@ export declare function createMemory(content: string, options?: {
     owner?: string | null;
     artifact_ref?: string | null;
     tenantId?: string;
-}): MemoryEntry;
+}
+/** Create a new memory entry with defaults. Untyped JavaScript callers that omit the options get the compiled default half-life. */
+export declare function createMemory(content: string, options: CreateMemoryOptions): MemoryEntry;
 /**
  * Compute how well new content fits existing knowledge patterns.
  * Returns 0..1 where:

package/dist/memory.js

@@ -11,13 +11,6 @@ export var Layer;
     Layer["Semantic"] = "semantic";
     Layer["Trace"] = "trace";
 })(Layer || (Layer = {}));
-export const DECISION_HALF_LIFE_DAYS = 90;
-export const INCIDENT_HALF_LIFE_DAYS = 90;
-export const PROCESS_HALF_LIFE_DAYS = 90;
-export const POLICY_HALF_LIFE_DAYS = 90;
-export const SKILL_HALF_LIFE_DAYS = 90;
-export const PROJECT_BRIEF_HALF_LIFE_DAYS = 90;
-export const CUSTOMER_NOTE_HALF_LIFE_DAYS = 90;
 /** FE2: tag on a memory whose named file/symbol/script changed after it was stored. */
 export const CHURN_STALE_TAG = 'churn-stale';
 // Emotional multipliers from PLAN.md.
@@ -326,9 +319,6 @@ export const AUTO_DELETABLE_SQL = "pinned = 0 AND kind != 'raw'";
 export function canAutoDelete(entry) {
     return !entry.pinned && entry.kind !== 'raw';
 }
-/**
- * Create a new memory entry with defaults.
- */
 export function createMemory(content, options = {}) {
     const trimmed = content.trim();
     if (trimmed.length < 3) {

package/dist/policies.js

@@ -39,8 +39,9 @@
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
 import { markGraphDirty, removeGraphEntitiesForObject } from './graph.js';
-import { createMemory, Layer, POLICY_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_POLICY_STATES = new Set([
     'active',
     'superseded',
@@ -144,9 +145,9 @@ export function savePolicy(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'policy',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = POLICY_HALF_LIFE_DAYS;
     let savedRow;
     writeEntry(hippoRoot, mem, {
         actor,

package/dist/predictions.js

@@ -28,6 +28,7 @@ import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
 import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
+import { loadConfig } from './config.js';
 import { detectForwardClaim } from './forward-claim-detector.js';
 export const VALID_CLOSURE_STATES = new Set([
     'open',
@@ -81,6 +82,7 @@ export function savePrediction(hippoRoot, tenantId, opts, actor = 'cli') {
         source: 'prediction',
         // SAFETY: 'distilled' is a valid MemoryKind literal (see memory.ts).
         kind: 'distilled',
+        baseHalfLifeDays: loadConfig(hippoRoot).defaultHalfLifeDays,
         tenantId,
     });
     // Captured for the return value; populated inside afterWrite hook so the

package/dist/processes.js

@@ -32,8 +32,9 @@
  */
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
-import { createMemory, Layer, PROCESS_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_PROCESS_STATES = new Set([
     'active',
     'superseded',
@@ -155,9 +156,9 @@ export function saveProcess(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'process',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = PROCESS_HALF_LIFE_DAYS;
     let savedRow;
     writeEntry(hippoRoot, mem, {
         actor,

package/dist/project-briefs.js

@@ -24,8 +24,9 @@
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId, RECALL_DEFAULT_DENY_SCOPES } from './store.js';
 import { markGraphDirty, removeGraphEntitiesForObject } from './graph.js';
-import { createMemory, Layer, PROJECT_BRIEF_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_BRIEF_STATES = new Set([
     'active',
     'superseded',
@@ -125,9 +126,9 @@ export function saveProjectBrief(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'project_brief',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = PROJECT_BRIEF_HALF_LIFE_DAYS;
     let savedRow;
     writeEntry(hippoRoot, mem, {
         actor,

package/dist/skills.js

@@ -23,8 +23,9 @@
  */
 import { openHippoDb, closeHippoDb } from './db.js';
 import { writeEntry, assertTenantId } from './store.js';
-import { createMemory, Layer, SKILL_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_SKILL_STATES = new Set([
     'active',
     'superseded',
@@ -130,9 +131,9 @@ export function saveSkill(hippoRoot, tenantId, opts, actor = 'cli') {
         layer: Layer.Semantic,
         confidence: 'verified',
         source: 'skill',
+        baseHalfLifeDays: objectHalfLifeDays(hippoRoot),
         tenantId,
     });
-    mem.half_life_days = SKILL_HALF_LIFE_DAYS;
     let savedRow;
     writeEntry(hippoRoot, mem, {
         actor,

package/dist/store.d.ts

@@ -113,6 +113,8 @@ export declare function initStore(hippoRoot: string): void;
 export declare function openStore(hippoRoot: string): DatabaseSyncLike;
 /** `meta` key holding the default half-life base a store's memories are on (src/half-life-migration.ts). */
 export declare const HALF_LIFE_BASE_META_KEY = "default_half_life_base";
+/** `meta` key set once no memory of a decision, incident or other object sits on the old flat 90 days. */
+export declare const TYPED_HALF_LIFE_META_KEY = "typed_half_life_on_default";
 /**
  * Serialize a MemoryEntry to markdown with YAML frontmatter.
  */

package/dist/store.js

@@ -140,6 +140,8 @@ export function openStore(hippoRoot) {
 }
 /** `meta` key holding the default half-life base a store's memories are on (src/half-life-migration.ts). */
 export const HALF_LIFE_BASE_META_KEY = 'default_half_life_base';
+/** `meta` key set once no memory of a decision, incident or other object sits on the old flat 90 days. */
+export const TYPED_HALF_LIFE_META_KEY = 'typed_half_life_on_default';
 /**
  * A store with no memories starts on the current default half-life base, so
  * `hippo sleep` never migrates it. A store that already holds memories and
@@ -152,6 +154,7 @@ function recordHalfLifeBaseForNewStore(db) {
     if (db.prepare(`SELECT 1 AS x FROM memories LIMIT 1`).get() !== undefined)
         return;
     setMeta(db, HALF_LIFE_BASE_META_KEY, String(DEFAULT_HALF_LIFE_DAYS));
+    setMeta(db, TYPED_HALF_LIFE_META_KEY, '1');
 }
 function ensureMirrorDirectories(hippoRoot) {
     const dirs = [