hippo-memory 1.52.6 → 1.52.8

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/dashboard.js

@@ -5,8 +5,10 @@
  * Usage: hippo dashboard [--port 3333]
  */
 import * as http from 'http';
+import * as os from 'os';
 import * as path from 'path';
 import * as fs from 'fs';
+import { extractPathTags } from './path-context.js';
 import { loadAllEntries, listCards, listMemoryConflicts, readEntry, writeEntry } from './store.js';
 import { calculateStrength, confidenceFacets } from './memory.js';
 import { loadConfig } from './config.js';
@@ -110,6 +112,8 @@ function buildDashboardData(hippoRoot) {
             defaultHalfLifeDays: config.defaultHalfLifeDays,
             defaultBudget: config.defaultBudget,
             embeddingsEnabled: config.embeddings.enabled,
+            // Every memory captured in the home folder carries these, so they name no project.
+            homePathTags: extractPathTags(os.homedir()),
         },
     };
 }

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;

package/dist/extensions/openclaw-plugin/index.js

@@ -172,6 +172,7 @@ function runHippo(args, cwd) {
             encoding: 'utf8',
             timeout: 30_000,
             stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
         });
         // `encoding: 'utf8'` above selects the ExecFileSyncOptionsWithStringEncoding
         // overload, so `result` is always a `string` here — no runtime check needed.

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/graph-recall.js

@@ -61,12 +61,9 @@ function loadByIdsChunked(root, tenantId, ids) {
     }
     return out;
 }
-/**
- * Traverse one store's graph from the seeds present in it and accumulate new graph hits
- * into `hitsByOrigin`. Mutates `seenMemoryIds` so a memory is surfaced at most once across
- * stores. Pure reads.
- */
-function produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds, hitsByOrigin, opts) {
+/** Traverse one store's graph from its seeds into `hitsByOrigin`. Pure reads; mutates `seenMemoryIds`
+ *  and `seenContent` so a memory, or a share/promote copy of it, surfaces at most once across stores. */
+function produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds, seenContent, hitsByOrigin, opts) {
     const { hops, maxNeighbors, tenantId, includeSuperseded, asOfDate, recallScope } = opts;
     // Seeds = graph entities (in THIS store) whose source memory is a base result.
     const seedEntities = loadEntitiesByMemoryId(root, tenantId, baseResults.map((r) => r.entry.id));
@@ -147,6 +144,8 @@ function produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds,
             continue; // not found / wrong tenant / already in base
         if (seenMemoryIds.has(mem.id))
             continue; // another reached entity already added it
+        if (seenContent.has(mem.content))
+            continue; // share/promote copy: same text, another id
         const via = reached.get(ent.id);
         // A node reached as the `to` endpoint of a `supersedes` edge IS the superseded
         // (older) version — the graph is the authoritative signal (the memory mirror's
@@ -175,6 +174,7 @@ function produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds,
         const origin = originMemByEntityId.get(ent.id) ?? baseResults[0].entry.id;
         const originScore = baseScoreByMemId.get(origin) ?? baseResults[baseResults.length - 1].score;
         seenMemoryIds.add(mem.id);
+        seenContent.add(mem.content);
         const hit = {
             entry: mem,
             score: originScore * (1 - HOP_DISCOUNT * via.hops),
@@ -209,11 +209,12 @@ export function graphExpandRecall(baseResults, opts) {
     const recallScope = opts.recallScope ?? {};
     const baseScoreByMemId = new Map(baseResults.map((r) => [r.entry.id, r.score]));
     const seenMemoryIds = new Set(baseResults.map((r) => r.entry.id));
+    const seenContent = new Set(baseResults.map((r) => r.entry.content));
     const hitsByOrigin = new Map();
     // Expand against each distinct store the seeds may live in (local + global).
     const roots = globalRoot && globalRoot !== hippoRoot ? [hippoRoot, globalRoot] : [hippoRoot];
     for (const root of roots) {
-        produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds, hitsByOrigin, {
+        produceHitsForRoot(root, baseResults, baseScoreByMemId, seenMemoryIds, seenContent, hitsByOrigin, {
             hops, maxNeighbors, tenantId, includeSuperseded, asOfDate, recallScope,
         });
     }

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/handoff.d.ts

@@ -12,6 +12,8 @@ export interface HandoffEvidence {
     gitRef?: string | null;
     dirtyTree?: boolean | null;
     testStatus?: 'pass' | 'fail' | 'unknown' | null;
+    /** 'transcript' when hippo read the handoff off the session's transcript at session end; a later exit may replace it. */
+    derivedFrom?: 'transcript';
 }
 /** Narrows an unvalidated value (e.g. CLI input or event content) to a HandoffOutcome. */
 export declare function isHandoffOutcome(v: string | boolean | string[] | null | undefined): v is HandoffOutcome;

package/dist/hooks.d.ts

@@ -10,8 +10,8 @@
  *        sequence, writing both outputs to the log file. The parent returns in
  *        <100ms so the TUI teardown can't kill the child before it finishes.
  *      - SessionStart: `hippo last-sleep --path <path>` - prints the log
- *        written by the previous session's detached worker and then clears it,
- *        so the user actually sees what was consolidated.
+ *        written by the previous session's detached worker to stderr, which
+ *        keeps it out of the model's context, and then clears it.
  *    Earlier Claude Code forms are detected and migrated automatically:
  *      - < 0.20.2: `Stop` hook firing `hippo sleep` on every assistant turn.
  *      - < 0.21.0: bare `hippo sleep` in SessionEnd, no `--log-file`.
@@ -60,7 +60,7 @@ export interface CodexWrapperMetadata {
     installedAt: string;
 }
 export interface EnsureCodexWrapperResult {
-    status: 'installed' | 'already-installed' | 'not-found';
+    status: 'installed' | 'already-installed' | 'not-found' | 'source-checkout';
     metadataPath?: string;
     realCodexPath?: string;
     commandPath?: string;
@@ -172,7 +172,7 @@ export declare function isCodexWrapperInstalled(): boolean;
  * doing it from postinstall or routine commands is a consent violation and
  * reads as binary hijacking to security scanners (issue #133).
  */
-export declare function repairCodexWrapperIfInstalled(): EnsureCodexWrapperResult;
+export declare function repairCodexWrapperIfInstalled(hippoCliPath?: string): EnsureCodexWrapperResult;
 export declare function resolveCodexSessionTranscript(options: CodexSessionTranscriptOptions): string | null;
 export declare function resolveJsonHookPaths(target: JsonHookTarget): JsonHookPaths;
 export declare function installJsonHooks(target: JsonHookTarget): InstallResult;

package/dist/hooks.js

@@ -10,8 +10,8 @@
  *        sequence, writing both outputs to the log file. The parent returns in
  *        <100ms so the TUI teardown can't kill the child before it finishes.
  *      - SessionStart: `hippo last-sleep --path <path>` - prints the log
- *        written by the previous session's detached worker and then clears it,
- *        so the user actually sees what was consolidated.
+ *        written by the previous session's detached worker to stderr, which
+ *        keeps it out of the model's context, and then clears it.
  *    Earlier Claude Code forms are detected and migrated automatically:
  *      - < 0.20.2: `Stop` hook firing `hippo sleep` on every assistant turn.
  *      - < 0.21.0: bare `hippo sleep` in SessionEnd, no `--log-file`.
@@ -412,10 +412,16 @@ export function isCodexWrapperInstalled() {
  * doing it from postinstall or routine commands is a consent violation and
  * reads as binary hijacking to security scanners (issue #133).
  */
-export function repairCodexWrapperIfInstalled() {
+export function repairCodexWrapperIfInstalled(hippoCliPath = resolveHippoCliPath()) {
     if (readCodexWrapperMetadata() === null) {
         return { status: 'not-found' };
     }
+    // A checkout's own `npm install` or CLI would point the user's launcher at a folder that may be deleted.
+    // SHORTCUT: any node_modules copy (npx cache, a project dependency) still repairs; record the opted-in CLI path in the metadata to close that.
+    const packageDir = path.dirname(path.dirname(hippoCliPath));
+    if (path.basename(path.dirname(packageDir)).toLowerCase() !== 'node_modules') {
+        return { status: 'source-checkout' };
+    }
     return ensureCodexWrapperInstalled();
 }
 function collectFiles(dir) {
@@ -966,7 +972,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;
 /**