hippo-memory 1.69.0 → 1.71.0

package/dist/graph/rows.d.ts

@@ -1,45 +0,0 @@
-import type { Entity, Relation, GraphQueueItem } from './types.js';
-export interface EntityRow {
-    id: number;
-    tenant_id: string;
-    entity_type: string;
-    name: string;
-    memory_id: string | null;
-    source_kind: string;
-    source_object_type: string | null;
-    source_object_id: number | null;
-    created_at: string;
-}
-export interface RelationRow {
-    id: number;
-    tenant_id: string;
-    from_entity_id: number;
-    to_entity_id: number;
-    rel_type: string;
-    memory_id: string | null;
-    source_kind: string;
-    source_object_type: string | null;
-    source_object_id: number | null;
-    created_at: string;
-}
-export interface QueueRow {
-    id: number;
-    tenant_id: string;
-    memory_id: string;
-    kind: string;
-    status: string;
-    enqueued_at: string;
-    processed_at: string | null;
-}
-export declare function rowToEntity(row: EntityRow): Entity;
-export declare function rowToRelation(row: RelationRow): Relation;
-export declare function rowToQueueItem(row: QueueRow): GraphQueueItem;
-export declare const ENTITY_COLS = "id, tenant_id, entity_type, name, memory_id, source_kind, source_object_type, source_object_id, created_at";
-export declare const RELATION_COLS = "id, tenant_id, from_entity_id, to_entity_id, rel_type, memory_id, source_kind, source_object_type, source_object_id, created_at";
-export declare const QUEUE_COLS = "id, tenant_id, memory_id, kind, status, enqueued_at, processed_at";
-export interface DbLike {
-    prepare(sql: string): {
-        get<T>(...params: unknown[]): T;
-    };
-}
-//# sourceMappingURL=rows.d.ts.map

package/dist/graph/types.js

@@ -1,11 +0,0 @@
-export const GRAPH_ENTITY_TYPES = new Set([
-    'person', 'project', 'customer', 'system', 'policy', 'decision',
-]);
-export const GRAPH_RELATION_TYPES = new Set([
-    'owns', 'supersedes', 'depends-on', 'blocked-by', 'references',
-]);
-export const VALID_QUEUE_STATES = new Set([
-    'pending', 'processed', 'skipped',
-]);
-export const MAX_ENTITY_NAME_LEN = 512;
-//# sourceMappingURL=types.js.map

package/dist/graph-stream.d.ts

@@ -1,70 +0,0 @@
-/**
- * Graph-retrieval ranked-list stream for RRF fusion.
- *
- * READ-ONLY consumer of the entity/relation graph. Produces a ranked list of
- * `entries[]` indices ordered by graph
- * proximity to the strong lexical seeds, for use as a 3rd fusion input to `rrfFuse`
- * beside BM25 + dense (src/search.ts hybridSearch, scoring:'rrf').
- *
- * DISTINCT from graph-recall.ts: that INJECTS out-of-pool neighbours post-hoc; this
- * RE-RANKS within the already-filtered candidate pool. It only assigns ranks to
- * entries that are (a) graph-reached from a seed AND (b) present in `entries[]`. Seeds
- * themselves are never scored (they already rank via BM25/dense; scoring them would
- * double-count and dilute the orthogonal graph signal).
- *
- * Reuses the BFS traversal shape from graph-recall.ts (loadEntitiesByMemoryId
- * seeds -> loadNeighborRelations BFS both directions, per-hop fanout cap, visited set
- * -> loadEntitiesByIds to resolve reached -> memoryId). Expands across the local AND
- * global stores. Pure reads (SELECTs only via graph.ts helpers), so the
- * check-graph-writes lint permits this module living outside graph.ts.
- *
- * The graph stream's score scale (1/lexRank seed strength x decay^hops) only sets the
- * WITHIN-graph-stream ORDERING; RRF then re-ranks the list by 1/(k + graphRank), so the
- * absolute magnitude is washed out by fusion. Do not tune the scale expecting a
- * fused-score effect — only the induced order matters.
- */
-import type { MemoryEntry } from './memory.js';
-/** Default hops expanded from each seed (MVP; hard cap MAX_HOPS=3 reused from graph-recall). */
-export declare const DEFAULT_GRAPH_HOPS = 2;
-/** Default per-hop multiplicative decay applied to the seed strength. */
-export declare const DEFAULT_GRAPH_DECAY = 0.5;
-/** Default number of top lexical seeds expanded from. */
-export declare const DEFAULT_GRAPH_SEED_COUNT = 10;
-/** Recommended RRF weight for the graph stream — a CLI-only convenience default. The
- *  library `graphStream.weight` option stays REQUIRED (opt-in is explicit). */
-export declare const DEFAULT_GRAPH_STREAM_WEIGHT = 0.5;
-/** A lexical seed to expand the graph from: a candidate index + its lexical strength. */
-export interface GraphSeed {
-    /** Index into the caller's `entries[]`. */
-    index: number;
-    /** Lexical strength (1/lexRank); higher = stronger seed. Propagated x decay^hops. */
-    strength: number;
-}
-export interface GraphStreamOpts {
-    hippoRoot: string;
-    tenantId: string;
-    /** The global store root, when distinct + initialized (where global seeds' graph lives). */
-    globalRoot?: string;
-    /** Hops to expand from each seed. Clamped to [1, MAX_HOPS]. Default DEFAULT_GRAPH_HOPS. */
-    hops?: number;
-    /** Per-hop multiplicative decay on the seed strength. Default DEFAULT_GRAPH_DECAY. */
-    decay?: number;
-    /** Per-hop fanout cap. Default DEFAULT_MAX_NEIGHBORS. */
-    maxNeighbors?: number;
-}
-/**
- * Pick the top `seedCount` candidates by best lexical rank (lowest position across the
- * BM25 and dense ranked lists), with strength = 1/(bestRank + 1). Pure; exported for
- * direct unit testing. A candidate present in either ranked list is eligible.
- */
-export declare function selectGraphSeeds(bm25Ranked: ReadonlyArray<number>, cosineRanked: ReadonlyArray<number>, seedCount: number): GraphSeed[];
-/**
- * Produce the graph-retrieval ranked list: `entries[]` indices ordered by graph
- * proximity (desc) to the lexical `seeds`. Only graph-reached, in-pool, non-seed
- * indices appear; the rest are absent (-> rrfFuse absentRank). Pure reads.
- *
- * Returns `[]` when there are no seeds/entries, the graph is empty, no seed maps to an
- * entity, or nothing reached is in-pool — the caller then skips the 3rd fusion list.
- */
-export declare function graphRankStream(entries: ReadonlyArray<MemoryEntry>, seeds: ReadonlyArray<GraphSeed>, opts: GraphStreamOpts): number[];
-//# sourceMappingURL=graph-stream.d.ts.map

package/dist/graph-view.d.ts

@@ -1,73 +0,0 @@
-/**
- * Graph observability and visualization, READ-ONLY over the entity/relation
- * graph.
- *
- * This module only READS the graph (`loadEntities` / `loadRelations`) and renders
- * view-models; it issues no INSERT/UPDATE/DELETE, so `scripts/check-graph-writes.mjs`
- * stays green. Used by the CLI (`hippo graph show` / `hippo graph view`) and the
- * HTTP `GET /v1/graph` route, which all build the same `GraphModel`.
- */
-import { type EntityType, type RelationType } from './graph/types.js';
-export interface GraphNode {
-    id: number;
-    type: EntityType;
-    name: string;
-}
-export interface GraphEdge {
-    from: number;
-    to: number;
-    relType: RelationType;
-}
-export interface GraphModel {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-    /** Conservative "maybe incomplete" flag: true when a loader returned exactly
-     *  its limit (the graph MAY be truncated). Can over-report, never under-report. */
-    truncated: boolean;
-}
-/** Default bound for the CLI viewer / show so an unbounded set is never laid out. */
-export declare const DEFAULT_VIEW_LIMIT = 500;
-/**
- * Build the view-model from the graph (reads only). With `opts.entity`, returns a
- * focus subgraph: every entity whose name === entity, plus their 1-hop neighbours,
- * plus the edges among that union. Dangling edges (an endpoint outside the node
- * set) are always dropped.
- */
-export declare function buildGraphModel(hippoRoot: string, tenantId: string, opts?: {
-    entity?: string;
-    limit?: number;
-    canRead?: (scope: string | null) => boolean;
-}): GraphModel;
-/**
- * Deterministic Fruchterman-Reingold-style force layout. Seeded circular init +
- * fixed iterations, NO `Math.random`, so the same model always yields the same
- * positions (testable, stable output). Non-finite coordinates from a degenerate
- * step are clamped to the viewport centre; all positions are clamped in-bounds.
- */
-export declare function layoutGraph(model: GraphModel, opts?: {
-    width?: number;
-    height?: number;
-    iterations?: number;
-}): Map<number, {
-    x: number;
-    y: number;
-}>;
-/** HTML-escape for SVG text / title / markup content (XSS guard). */
-export declare function escapeHtml(s: string): string;
-/**
- * Render the model as a SELF-CONTAINED, dependency-free, offline interactive HTML
- * node-link diagram. Positions are computed server-side (deterministic). User
- * strings are escaped per sink: SVG `<text>`/`<title>` via `escapeHtml`; the model
- * is inlined in a `<script type="application/json">` block with `<`/`>`/`&`
- * unicode-escaped so a `</script>` inside an entity name cannot break out (the
- * client `JSON.parse`s it back and never `innerHTML`s a user string).
- */
-export declare function renderGraphHtml(model: GraphModel): string;
-/**
- * Render the model as a JSON Canvas (jsoncanvas.org) document — `nodes[]` of
- * type `text` positioned by the same deterministic layout, `edges[]` linking
- * them by id. Opens natively in Obsidian. Pure JSON; entity names live in the
- * `text` field (Obsidian renders/sanitizes them).
- */
-export declare function renderGraphCanvas(model: GraphModel): string;
-//# sourceMappingURL=graph-view.d.ts.map

package/dist/graph-view.js

@@ -1,333 +0,0 @@
-/**
- * Graph observability and visualization, READ-ONLY over the entity/relation
- * graph.
- *
- * This module only READS the graph (`loadEntities` / `loadRelations`) and renders
- * view-models; it issues no INSERT/UPDATE/DELETE, so `scripts/check-graph-writes.mjs`
- * stays green. Used by the CLI (`hippo graph show` / `hippo graph view`) and the
- * HTTP `GET /v1/graph` route, which all build the same `GraphModel`.
- */
-import { loadEntities, loadEntitiesByName, loadEntitiesByIds, loadRelations, loadNeighborRelations, loadRelationsAmong, withGraphReadSnapshot, } from './graph/read.js';
-/** Default bound for the CLI viewer / show so an unbounded set is never laid out. */
-export const DEFAULT_VIEW_LIMIT = 500;
-// graph/read.ts's IN-list chunk, so one statement stays far under SQLite's bound-parameter limit.
-const MEMORY_ID_CHUNK = 400;
-/** The items whose source memory `canRead` admits: a NULL memoryId has no scope to hide, and a missing memory fails closed. */
-function readableOnly(db, tenantId, items, canRead) {
-    if (!canRead)
-        return items;
-    const ids = [...new Set(items.flatMap((i) => (i.memoryId === null ? [] : [i.memoryId])))];
-    const readable = new Set();
-    for (let i = 0; i < ids.length; i += MEMORY_ID_CHUNK) {
-        const slice = ids.slice(i, i + MEMORY_ID_CHUNK);
-        // SAFETY: rows' shape matches the id and scope columns named in the SELECT.
-        const rows = db.prepare(`SELECT id, scope FROM memories WHERE tenant_id = ? AND id IN (${slice.map(() => '?').join(',')})`)
-            .all(tenantId, ...slice);
-        for (const r of rows)
-            if (canRead(r.scope))
-                readable.add(r.id);
-    }
-    return items.filter((i) => i.memoryId === null || readable.has(i.memoryId));
-}
-/**
- * Build the view-model from the graph (reads only). With `opts.entity`, returns a
- * focus subgraph: every entity whose name === entity, plus their 1-hop neighbours,
- * plus the edges among that union. Dangling edges (an endpoint outside the node
- * set) are always dropped.
- */
-export function buildGraphModel(hippoRoot, tenantId, opts = {}) {
-    const limit = opts.limit ?? DEFAULT_VIEW_LIMIT;
-    // All reads run inside ONE read snapshot so a concurrent `graph extract` /
-    // sleep-drain rebuild can't make the model mix old entity ids with new relation
-    // ids. Every load* call below is passed the snapshot connection `db`.
-    return withGraphReadSnapshot(hippoRoot, (db) => {
-        let nodeEntities;
-        let relations;
-        let truncated;
-        if (opts.entity !== undefined) {
-            // Focus subgraph. (1) Query the named entity DIRECTLY (by name, not from a
-            // globally-capped list) so it is found even on a graph larger than `limit`.
-            // (2) A name can map to MANY entities (e.g. many notes for one customer), so
-            // cap the focus matches. (3) Discover 1-hop neighbours and cap the UNION to
-            // `limit` nodes. (4) Load ALL edges AMONG the union so neighbour-to-neighbour
-            // edges that don't touch the focus are included too.
-            const named = loadEntitiesByName(hippoRoot, tenantId, opts.entity, { limit }, db);
-            // A hidden focus must not answer through its neighbours that the name exists.
-            const focus = readableOnly(db, tenantId, named, opts.canRead);
-            if (focus.length === 0)
-                return { nodes: [], edges: [], truncated: false };
-            const focusIds = focus.map((e) => e.id);
-            const hop = loadNeighborRelations(hippoRoot, tenantId, focusIds, { limit }, db);
-            const union = new Set(focusIds);
-            let neighboursCapped = false;
-            for (const r of hop) {
-                if (union.size >= limit) {
-                    neighboursCapped = true; // node cap filled before all neighbours were added
-                    break;
-                }
-                union.add(r.fromEntityId);
-                union.add(r.toEntityId);
-            }
-            const unionIds = [...union].slice(0, limit);
-            nodeEntities = loadEntitiesByIds(hippoRoot, tenantId, unionIds, db);
-            // Edges AMONG the union (BOTH endpoints in the set): includes
-            // neighbour-to-neighbour edges, and the LIMIT can never drop a valid in-union
-            // edge in favour of out-of-union rows.
-            relations = loadRelationsAmong(hippoRoot, tenantId, unionIds, { limit }, db);
-            truncated =
-                named.length >= limit ||
-                    hop.length >= limit || // neighbour scan capped -> a 1-hop neighbour may be omitted
-                    neighboursCapped || // node cap filled before all neighbours were consumed
-                    union.size > unionIds.length ||
-                    relations.length >= limit;
-        }
-        else {
-            nodeEntities = loadEntities(hippoRoot, tenantId, { limit }, db);
-            relations = loadRelations(hippoRoot, tenantId, { limit }, db);
-            truncated = nodeEntities.length >= limit || relations.length >= limit;
-        }
-        nodeEntities = readableOnly(db, tenantId, nodeEntities, opts.canRead);
-        relations = readableOnly(db, tenantId, relations, opts.canRead);
-        const nodeIds = new Set(nodeEntities.map((e) => e.id));
-        const nodes = nodeEntities.map((e) => ({
-            id: e.id,
-            type: e.entityType,
-            name: e.name,
-        }));
-        const edges = relations
-            .filter((r) => nodeIds.has(r.fromEntityId) && nodeIds.has(r.toEntityId))
-            .map((r) => ({ from: r.fromEntityId, to: r.toEntityId, relType: r.relType }));
-        return { nodes, edges, truncated };
-    });
-}
-const LAYOUT_W = 1000;
-const LAYOUT_H = 700;
-/**
- * Deterministic Fruchterman-Reingold-style force layout. Seeded circular init +
- * fixed iterations, NO `Math.random`, so the same model always yields the same
- * positions (testable, stable output). Non-finite coordinates from a degenerate
- * step are clamped to the viewport centre; all positions are clamped in-bounds.
- */
-export function layoutGraph(model, opts = {}) {
-    const width = opts.width ?? LAYOUT_W;
-    const height = opts.height ?? LAYOUT_H;
-    const iterations = opts.iterations ?? 300;
-    const cx = width / 2;
-    const cy = height / 2;
-    const nodes = model.nodes;
-    const n = nodes.length;
-    const pos = new Map();
-    if (n === 0)
-        return pos;
-    if (n === 1) {
-        pos.set(nodes[0].id, { x: cx, y: cy });
-        return pos;
-    }
-    const radius = Math.min(width, height) * 0.4;
-    nodes.forEach((node, i) => {
-        const angle = (2 * Math.PI * i) / n;
-        pos.set(node.id, { x: cx + radius * Math.cos(angle), y: cy + radius * Math.sin(angle) });
-    });
-    const idIndex = new Map(nodes.map((node, i) => [node.id, i]));
-    const k = Math.sqrt((width * height) / n); // ideal edge length
-    for (let iter = 0; iter < iterations; iter++) {
-        const disp = nodes.map(() => ({ x: 0, y: 0 }));
-        // Repulsion between all pairs.
-        for (let i = 0; i < n; i++) {
-            const pi = pos.get(nodes[i].id);
-            for (let j = i + 1; j < n; j++) {
-                const pj = pos.get(nodes[j].id);
-                const dx = pi.x - pj.x;
-                const dy = pi.y - pj.y;
-                const dist = Math.hypot(dx, dy) || 0.01;
-                const rep = (k * k) / dist;
-                const ux = dx / dist;
-                const uy = dy / dist;
-                disp[i].x += ux * rep;
-                disp[i].y += uy * rep;
-                disp[j].x -= ux * rep;
-                disp[j].y -= uy * rep;
-            }
-        }
-        // Attraction along edges.
-        for (const e of model.edges) {
-            const i = idIndex.get(e.from);
-            const j = idIndex.get(e.to);
-            if (i === undefined || j === undefined)
-                continue;
-            const pi = pos.get(e.from);
-            const pj = pos.get(e.to);
-            const dx = pi.x - pj.x;
-            const dy = pi.y - pj.y;
-            const dist = Math.hypot(dx, dy) || 0.01;
-            const att = (dist * dist) / k;
-            const ux = dx / dist;
-            const uy = dy / dist;
-            disp[i].x -= ux * att;
-            disp[i].y -= uy * att;
-            disp[j].x += ux * att;
-            disp[j].y += uy * att;
-        }
-        // Apply with cooling; clamp.
-        const temp = Math.max(1, (width / 10) * (1 - iter / iterations));
-        nodes.forEach((node, i) => {
-            const p = pos.get(node.id);
-            const dl = Math.hypot(disp[i].x, disp[i].y) || 0.01;
-            let nx = p.x + (disp[i].x / dl) * Math.min(dl, temp);
-            let ny = p.y + (disp[i].y / dl) * Math.min(dl, temp);
-            if (!Number.isFinite(nx))
-                nx = cx;
-            if (!Number.isFinite(ny))
-                ny = cy;
-            p.x = Math.max(20, Math.min(width - 20, nx));
-            p.y = Math.max(20, Math.min(height - 20, ny));
-        });
-    }
-    return pos;
-}
-/** HTML-escape for SVG text / title / markup content (XSS guard). */
-export function escapeHtml(s) {
-    return s
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
-}
-const NODE_COLORS = {
-    decision: '#6366f1',
-    policy: '#10b981',
-    customer: '#f59e0b',
-    project: '#ec4899',
-    person: '#3b82f6',
-    system: '#64748b',
-};
-// Client script: pan (drag bg), zoom (wheel), click-to-highlight a node's edges +
-// neighbours. Reads the inlined model via JSON.parse (never innerHTML), so user
-// strings never reach an HTML sink here. No template literals / `${}` so it nests
-// safely inside this module's own template strings.
-const CLIENT_JS = [
-    "(function(){",
-    "  var svg=document.getElementById('g');",
-    "  var vb=svg.getAttribute('viewBox').split(' ').map(Number);",
-    "  var view={x:vb[0],y:vb[1],w:vb[2],h:vb[3]};",
-    "  function apply(){svg.setAttribute('viewBox',view.x+' '+view.y+' '+view.w+' '+view.h);}",
-    "  var panning=false,sx=0,sy=0;",
-    "  svg.addEventListener('mousedown',function(e){if(e.target.closest('.node'))return;panning=true;sx=e.clientX;sy=e.clientY;});",
-    "  window.addEventListener('mouseup',function(){panning=false;});",
-    "  window.addEventListener('mousemove',function(e){if(!panning)return;var r=svg.getBoundingClientRect();var k=view.w/r.width;view.x-=(e.clientX-sx)*k;view.y-=(e.clientY-sy)*k;sx=e.clientX;sy=e.clientY;apply();});",
-    "  svg.addEventListener('wheel',function(e){e.preventDefault();var r=svg.getBoundingClientRect();var mx=view.x+(e.clientX-r.left)/r.width*view.w;var my=view.y+(e.clientY-r.top)/r.height*view.h;var f=e.deltaY<0?0.9:1.1;view.x=mx-(mx-view.x)*f;view.y=my-(my-view.y)*f;view.w*=f;view.h*=f;apply();},{passive:false});",
-    "  var data={};try{data=JSON.parse(document.getElementById('graph-data').textContent);}catch(_){}",
-    "  var adj={};(data.edges||[]).forEach(function(e){(adj[e.from]=adj[e.from]||[]).push(e.to);(adj[e.to]=adj[e.to]||[]).push(e.from);});",
-    "  var active=null;",
-    "  document.querySelectorAll('.node').forEach(function(g){g.addEventListener('click',function(ev){ev.stopPropagation();var id=g.getAttribute('data-id');if(active===id){clearHi();active=null;return;}active=id;highlight(id);});});",
-    "  svg.addEventListener('click',function(){clearHi();active=null;});",
-    "  function clearHi(){svg.classList.remove('focused');document.querySelectorAll('.hi').forEach(function(el){el.classList.remove('hi');});}",
-    "  function highlight(id){clearHi();svg.classList.add('focused');var keep={};keep[id]=1;(adj[id]||[]).forEach(function(n){keep[n]=1;});document.querySelectorAll('.node').forEach(function(g){if(keep[g.getAttribute('data-id')])g.classList.add('hi');});document.querySelectorAll('.edge').forEach(function(l){if(l.getAttribute('data-from')===id||l.getAttribute('data-to')===id)l.classList.add('hi');});}",
-    "})();",
-].join("\n");
-const STYLE = [
-    "html,body{margin:0;height:100%;background:#0b1020;font-family:ui-sans-serif,system-ui,sans-serif}",
-    "#g{width:100vw;height:100vh;cursor:grab}",
-    "#g:active{cursor:grabbing}",
-    ".edge{stroke:#475569;stroke-width:1}",
-    ".node circle{stroke:#0b1020;stroke-width:1.5}",
-    ".node text{fill:#e2e8f0;font-size:11px;pointer-events:none}",
-    ".node{cursor:pointer}",
-    "#g.focused .node{opacity:.18}",
-    "#g.focused .edge{opacity:.07}",
-    "#g.focused .node.hi{opacity:1}",
-    "#g.focused .edge.hi{opacity:1;stroke:#e2e8f0}",
-    ".legend{position:fixed;top:10px;left:12px;color:#94a3b8;font-size:12px;line-height:1.6}",
-    ".legend b{color:#e2e8f0}",
-].join("\n");
-/**
- * Render the model as a SELF-CONTAINED, dependency-free, offline interactive HTML
- * node-link diagram. Positions are computed server-side (deterministic). User
- * strings are escaped per sink: SVG `<text>`/`<title>` via `escapeHtml`; the model
- * is inlined in a `<script type="application/json">` block with `<`/`>`/`&`
- * unicode-escaped so a `</script>` inside an entity name cannot break out (the
- * client `JSON.parse`s it back and never `innerHTML`s a user string).
- */
-export function renderGraphHtml(model) {
-    const pos = layoutGraph(model);
-    const color = (t) => NODE_COLORS[t] ?? '#64748b';
-    const edgeSvg = model.edges
-        .map((e) => {
-        const a = pos.get(e.from);
-        const b = pos.get(e.to);
-        if (!a || !b)
-            return '';
-        return (`<line class="edge" data-from="${e.from}" data-to="${e.to}" ` +
-            `x1="${a.x.toFixed(1)}" y1="${a.y.toFixed(1)}" x2="${b.x.toFixed(1)}" y2="${b.y.toFixed(1)}"/>`);
-    })
-        .join('');
-    const nodeSvg = model.nodes
-        .map((node) => {
-        const p = pos.get(node.id);
-        if (!p)
-            return '';
-        const label = node.name.length > 22 ? node.name.slice(0, 21) + '…' : node.name;
-        return (`<g class="node" data-id="${node.id}" transform="translate(${p.x.toFixed(1)},${p.y.toFixed(1)})">` +
-            `<title>${escapeHtml(node.type + ': ' + node.name)}</title>` +
-            `<circle r="7" fill="${color(node.type)}"/>` +
-            `<text x="10" y="4">${escapeHtml(label)}</text>` +
-            `</g>`);
-    })
-        .join('');
-    // Safe inline JSON for the client: unicode-escape the HTML-significant chars so
-    // the content cannot terminate the <script> block; JSON.parse restores them.
-    const dataJson = JSON.stringify(model)
-        .replace(/</g, '\\u003c')
-        .replace(/>/g, '\\u003e')
-        .replace(/&/g, '\\u0026');
-    const types = [...new Set(model.nodes.map((nd) => nd.type))];
-    const legend = types
-        .map((t) => `<span style="color:${color(t)}">●</span> ${escapeHtml(t)}`)
-        .join('  ');
-    return [
-        '<!doctype html>',
-        '<html lang="en"><head><meta charset="utf-8">',
-        '<meta name="viewport" content="width=device-width, initial-scale=1">',
-        '<title>hippo graph</title>',
-        '<style>' + STYLE + '</style></head><body>',
-        `<div class="legend"><b>hippo graph</b> · ${model.nodes.length} entities · ${model.edges.length} relations` +
-            (model.truncated ? ' · <b style="color:#f59e0b">truncated</b>' : '') +
-            `<br>${legend}<br><span style="color:#64748b">drag to pan · scroll to zoom · click a node to focus</span></div>`,
-        `<svg id="g" viewBox="0 0 ${LAYOUT_W} ${LAYOUT_H}" preserveAspectRatio="xMidYMid meet">`,
-        `<g id="edges">${edgeSvg}</g><g id="nodes">${nodeSvg}</g>`,
-        '</svg>',
-        `<script type="application/json" id="graph-data">${dataJson}</script>`,
-        '<script>' + CLIENT_JS + '</script>',
-        '</body></html>',
-    ].join('\n');
-}
-/**
- * Render the model as a JSON Canvas (jsoncanvas.org) document — `nodes[]` of
- * type `text` positioned by the same deterministic layout, `edges[]` linking
- * them by id. Opens natively in Obsidian. Pure JSON; entity names live in the
- * `text` field (Obsidian renders/sanitizes them).
- */
-export function renderGraphCanvas(model) {
-    const pos = layoutGraph(model, { width: 2400, height: 1600 });
-    const nodes = model.nodes.map((node) => {
-        const p = pos.get(node.id) ?? { x: 0, y: 0 };
-        return {
-            id: `n${node.id}`,
-            type: 'text',
-            x: Math.round(p.x),
-            y: Math.round(p.y),
-            width: 240,
-            height: 60,
-            text: `**${node.type}**\n${node.name}`,
-        };
-    });
-    const edges = model.edges.map((e, i) => ({
-        id: `e${i}`,
-        fromNode: `n${e.from}`,
-        toNode: `n${e.to}`,
-        label: e.relType,
-    }));
-    return JSON.stringify({ nodes, edges }, null, 2);
-}
-//# sourceMappingURL=graph-view.js.map

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

@@ -1,63 +0,0 @@
-/**
- * Moving a store's memories to a new default half-life.
- *
- * Each memory stores its own `half_life_days`, set at write from the
- * default base and a few write-time multipliers (`deriveHalfLife`). Changing
- * the default therefore reaches only new memories; without this migration a
- * store would mix old-base and new-base memories, a state the decay
- * evaluation never tested. The rule, declared before any run:
- *
- * - only a memory still on the old base is rescaled: its half-life is
- *   `deriveHalfLife(from, entry)` plus its recall bonus. A memory hippo shortened since
- *   (invalidated, superseded, a merge source, marked bad) or one with its own
- *   fixed half-life (decisions, incidents, customer notes) keeps its value;
- * - every rescale is written to the audit log with the ids, so it can be
- *   undone, and the store records the base it is on (`meta`), so the
- *   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`. 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/open.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 {
-    from: number;
-    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;
-    /** New half-life per moved id, so a dry run can preview decay at the new base. */
-    halfLives: ReadonlyMap<string, number>;
-}
-type HalfLifeFields = Pick<MemoryEntry, 'half_life_days' | 'tags' | 'schema_fit' | 'retrieval_count' | 'superseded_by'>;
-/** 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, 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?: {
-    dryRun?: boolean;
-    actor?: string;
-}): HalfLifeMigrationResult;
-//# sourceMappingURL=half-life-migration.d.ts.map