hippo-memory 1.60.0 → 1.62.0

package/dist/dashboard-actions.d.ts

@@ -0,0 +1,20 @@
+import type { MemoryEntry } from './memory.js';
+import { type ActionBody } from './dashboard-params.js';
+/** What an action hands the router: a status, a JSON body, and whether the store changed. */
+export interface ActionResult {
+    status: number;
+    body: unknown;
+    /** True when a write committed, so the router drops the snapshot. */
+    changed: boolean;
+    /** The live entry an action acted on, so the router can build the detail after the cache is dropped. */
+    entry?: MemoryEntry;
+}
+/** Sets `pinned`; the audit row says `remember` with actor `dashboard`, the same op the old star toggle wrote. */
+export declare function pinMemory(hippoRoot: string, tenantId: string, rawId: string, body: ActionBody): ActionResult;
+/** Marks a memory wrong, the same signal as `hippo outcome --bad`. */
+export declare function markWrong(hippoRoot: string, tenantId: string, rawId: string): ActionResult;
+/** Deletes a memory like `hippo forget`; a raw receipt is append-only and answers 409 with the archive hint. */
+export declare function forgetMemory(hippoRoot: string, tenantId: string, rawId: string): ActionResult;
+/** Keeps one side of an open conflict and weakens the other; every refusal maps to its own status. */
+export declare function resolveOpenConflict(hippoRoot: string, tenantId: string, conflictId: number, body: ActionBody): ActionResult;
+//# sourceMappingURL=dashboard-actions.d.ts.map

package/dist/dashboard-actions.js

@@ -0,0 +1,88 @@
+// The four dashboard writes, each a thin call into an existing store or api function; the router owns HTTP and the cache.
+import * as api from './api.js';
+import { NotFoundError } from './api-errors.js';
+import { listMemoryConflicts, resolveConflict } from './store/conflicts.js';
+import { readEntry } from './store/entry-reads.js';
+import { writeEntry } from './store/entry-writes.js';
+import { ParamError, parseMemoryId } from './dashboard-params.js';
+import { isLiveMemory } from './dashboard-snapshot.js';
+const ACTOR = 'dashboard';
+function notFound() {
+    return { status: 404, body: { error: 'Not found' }, changed: false };
+}
+function liveEntry(hippoRoot, tenantId, id) {
+    const entry = readEntry(hippoRoot, id, tenantId);
+    return entry !== null && isLiveMemory(entry) ? entry : null;
+}
+/** Sets `pinned`; the audit row says `remember` with actor `dashboard`, the same op the old star toggle wrote. */
+export function pinMemory(hippoRoot, tenantId, rawId, body) {
+    const id = parseMemoryId(rawId);
+    const { pinned } = body;
+    if (pinned === undefined)
+        throw new ParamError('pinned must be true or false');
+    const entry = liveEntry(hippoRoot, tenantId, id);
+    if (entry === null)
+        return notFound();
+    const next = { ...entry, pinned };
+    writeEntry(hippoRoot, next, { actor: ACTOR });
+    return { status: 200, body: null, changed: true, entry: next };
+}
+/** Marks a memory wrong, the same signal as `hippo outcome --bad`. */
+export function markWrong(hippoRoot, tenantId, rawId) {
+    const id = parseMemoryId(rawId);
+    if (liveEntry(hippoRoot, tenantId, id) === null)
+        return notFound();
+    const ctx = { hippoRoot, tenantId, actor: api.adminActor(ACTOR) };
+    // outcome() answers `applied: 0` for a missing or other-tenant id instead of throwing.
+    if (api.outcome(ctx, [id], false).applied === 0)
+        return notFound();
+    const entry = readEntry(hippoRoot, id, tenantId);
+    return entry === null ? notFound() : { status: 200, body: null, changed: true, entry };
+}
+/** Deletes a memory like `hippo forget`; a raw receipt is append-only and answers 409 with the archive hint. */
+export function forgetMemory(hippoRoot, tenantId, rawId) {
+    const id = parseMemoryId(rawId);
+    if (liveEntry(hippoRoot, tenantId, id) === null)
+        return notFound();
+    const ctx = { hippoRoot, tenantId, actor: api.adminActor(ACTOR) };
+    try {
+        const done = api.forget(ctx, id);
+        return { status: 200, body: done, changed: true };
+    }
+    catch (err) {
+        if (err instanceof NotFoundError)
+            return notFound();
+        // Same match as cmdForget: the append-only trigger names itself in the message.
+        if (err instanceof Error && /append-only/i.test(err.message)) {
+            const error = `Cannot forget ${id}: it is a raw, append-only memory. Archive it instead: hippo forget ${id} --archive --reason "<why>"`;
+            return { status: 409, body: { error }, changed: false };
+        }
+        throw err;
+    }
+}
+/** Keeps one side of an open conflict and weakens the other; every refusal maps to its own status. */
+export function resolveOpenConflict(hippoRoot, tenantId, conflictId, body) {
+    const { keep } = body;
+    if (keep === undefined)
+        throw new ParamError('keep must be a memory id');
+    parseMemoryId(keep);
+    const conflict = listMemoryConflicts(hippoRoot, '*', tenantId).find((c) => c.id === conflictId);
+    if (!conflict)
+        return notFound();
+    const already = () => ({ status: 409, body: { error: 'This conflict is already resolved' }, changed: false });
+    if (conflict.status !== 'open')
+        return already();
+    if (keep !== conflict.memory_a_id && keep !== conflict.memory_b_id) {
+        throw new ParamError('keep must be one of the two memories in the conflict');
+    }
+    if (liveEntry(hippoRoot, tenantId, conflict.memory_a_id) === null || liveEntry(hippoRoot, tenantId, conflict.memory_b_id) === null) {
+        return notFound();
+    }
+    const resolved = resolveConflict(hippoRoot, conflictId, keep, false, tenantId, { rejectedBy: ACTOR });
+    // Both guards passed above, so null here is a race with another resolver.
+    if (resolved === null)
+        return already();
+    const result = { ok: true, conflictId, keptId: keep, weakenedId: resolved.loserId };
+    return { status: 200, body: result, changed: true };
+}
+//# sourceMappingURL=dashboard-actions.js.map

package/dist/dashboard-params.d.ts

@@ -0,0 +1,45 @@
+import { type Chip } from './dashboard-snapshot.js';
+/** A request field failed validation; the router answers 400 with this plain message. */
+export declare class ParamError extends Error {
+}
+export declare const SORT_KEYS: readonly ["content", "layer", "strength", "retrievals", "last", "age", "confidence", "scope"];
+export type SortKey = (typeof SORT_KEYS)[number];
+export type SortDir = 'asc' | 'desc';
+export declare const LIMIT_DEFAULT = 100;
+export declare const LIMIT_MAX = 500;
+export declare const SEARCH_MIN = 2;
+export declare const SEARCH_MAX = 200;
+export interface Brush {
+    amin: number;
+    amax: number;
+    smin: number;
+    smax: number;
+}
+export interface MemoryQuery {
+    offset: number;
+    limit: number;
+    sort: SortKey;
+    dir: SortDir;
+    chip: Chip;
+    /** Layer indices in wire order, ascending, no duplicates. */
+    layers: number[];
+    brush: Brush;
+    /** Lowercased search text, or null when none or shorter than the minimum. */
+    q: string | null;
+}
+/** Parses and validates the query of `GET /api/projects/:key/memories`. */
+export declare function parseMemoryQuery(params: URLSearchParams): MemoryQuery;
+/** Search text for `GET /api/search`: 2 to 200 characters after trim, returned as typed (trimmed). */
+export declare function parseSearchText(params: URLSearchParams): string;
+/** A memory id from a path segment. */
+export declare function parseMemoryId(raw: string): string;
+/** The only fields a dashboard POST reads; a field of the wrong type arrives as undefined. */
+export interface ActionBody {
+    pinned?: boolean;
+    keep?: string;
+}
+/** Parses a POST body once at the boundary; an empty body is `{}` and invalid JSON is a 400. */
+export declare function parseActionBody(text: string): ActionBody;
+/** A conflict id from a path segment: a positive integer. */
+export declare function parseConflictId(raw: string): number;
+//# sourceMappingURL=dashboard-params.d.ts.map

package/dist/dashboard-params.js

@@ -0,0 +1,127 @@
+// One shared parser for every dashboard query and path field, so no route trusts `parseInt` or an unchecked id.
+import { LAYERS } from './dashboard-snapshot.js';
+/** A request field failed validation; the router answers 400 with this plain message. */
+export class ParamError extends Error {
+}
+export const SORT_KEYS = ['content', 'layer', 'strength', 'retrievals', 'last', 'age', 'confidence', 'scope'];
+const CHIPS = ['all', 'risk', 'pinned', 'conflict'];
+const MEMORY_ID = /^[A-Za-z0-9_-]+$/;
+const INTEGER = /^-?\d+$/;
+export const LIMIT_DEFAULT = 100;
+export const LIMIT_MAX = 500;
+export const SEARCH_MIN = 2;
+export const SEARCH_MAX = 200;
+function integerParam(params, name, fallback, min, max) {
+    const raw = params.get(name);
+    if (raw === null)
+        return fallback;
+    const n = INTEGER.test(raw.trim()) ? Number(raw) : Number.NaN;
+    if (!Number.isInteger(n) || n < min || n > max) {
+        throw new ParamError(`${name} must be a whole number from ${min} to ${max}`);
+    }
+    return n;
+}
+function oneOf(params, name, allowed, fallback) {
+    const raw = params.get(name);
+    if (raw === null)
+        return fallback;
+    const hit = allowed.find((a) => a === raw);
+    if (hit === undefined)
+        throw new ParamError(`${name} must be one of ${allowed.join(', ')}`);
+    return hit;
+}
+function finiteParam(params, name) {
+    const raw = params.get(name);
+    if (raw === null)
+        return null;
+    const n = raw.trim() === '' ? Number.NaN : Number(raw);
+    if (!Number.isFinite(n))
+        throw new ParamError(`${name} must be a number`);
+    return n;
+}
+function layersParam(params) {
+    const raw = params.get('layers');
+    if (raw === null)
+        return LAYERS.map((_, i) => i);
+    const picked = new Set();
+    for (const part of raw.split(',')) {
+        const i = LAYERS.findIndex((l) => l === part.trim());
+        if (i === -1)
+            throw new ParamError(`layers must be a comma list of ${LAYERS.join(', ')}`);
+        picked.add(i);
+    }
+    return [...picked].sort((a, b) => a - b);
+}
+function rangeParam(params, lo, hi) {
+    const min = finiteParam(params, lo);
+    const max = finiteParam(params, hi);
+    if (min !== null && max !== null && min > max)
+        throw new ParamError(`${lo} must not exceed ${hi}`);
+    return [min ?? Number.NEGATIVE_INFINITY, max ?? Number.POSITIVE_INFINITY];
+}
+/** Search text for the memories route: shorter than the minimum means no filter; longer than the maximum is a 400. */
+function optionalSearch(params) {
+    const raw = params.get('q');
+    if (raw === null)
+        return null;
+    const q = raw.trim();
+    if (q.length > SEARCH_MAX)
+        throw new ParamError(`q must be at most ${SEARCH_MAX} characters`);
+    return q.length < SEARCH_MIN ? null : q.toLowerCase();
+}
+/** Parses and validates the query of `GET /api/projects/:key/memories`. */
+export function parseMemoryQuery(params) {
+    const [amin, amax] = rangeParam(params, 'amin', 'amax');
+    const [smin, smax] = rangeParam(params, 'smin', 'smax');
+    const sort = oneOf(params, 'sort', SORT_KEYS, 'strength');
+    return {
+        offset: integerParam(params, 'offset', 0, 0, Number.MAX_SAFE_INTEGER),
+        limit: integerParam(params, 'limit', LIMIT_DEFAULT, 1, LIMIT_MAX),
+        sort,
+        // Weakest first by default, like the mockup; retrievals starts with the most.
+        dir: oneOf(params, 'dir', ['asc', 'desc'], sort === 'retrievals' ? 'desc' : 'asc'),
+        chip: oneOf(params, 'chip', CHIPS, 'all'),
+        layers: layersParam(params),
+        brush: { amin, amax, smin, smax },
+        q: optionalSearch(params),
+    };
+}
+/** Search text for `GET /api/search`: 2 to 200 characters after trim, returned as typed (trimmed). */
+export function parseSearchText(params) {
+    const q = (params.get('q') ?? '').trim();
+    if (q.length < SEARCH_MIN || q.length > SEARCH_MAX) {
+        throw new ParamError(`q must be ${SEARCH_MIN} to ${SEARCH_MAX} characters`);
+    }
+    return q;
+}
+/** A memory id from a path segment. */
+export function parseMemoryId(raw) {
+    if (!MEMORY_ID.test(raw))
+        throw new ParamError('Invalid memory id');
+    return raw;
+}
+/** Parses a POST body once at the boundary; an empty body is `{}` and invalid JSON is a 400. */
+export function parseActionBody(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text === '' ? '{}' : text);
+    }
+    catch {
+        throw new ParamError('Body is not valid JSON');
+    }
+    const pinned = raw?.pinned;
+    const keep = raw?.keep;
+    // String(x) === x is true only for a string, which is the check without a typeof.
+    return {
+        pinned: pinned === true || pinned === false ? pinned : undefined,
+        keep: String(keep) === keep ? keep : undefined,
+    };
+}
+/** A conflict id from a path segment: a positive integer. */
+export function parseConflictId(raw) {
+    const n = INTEGER.test(raw) ? Number(raw) : Number.NaN;
+    if (!Number.isSafeInteger(n) || n < 1)
+        throw new ParamError('Invalid conflict id');
+    return n;
+}
+//# sourceMappingURL=dashboard-params.js.map

package/dist/dashboard-queries.d.ts

@@ -0,0 +1,15 @@
+import { type MemoryEntry } from './memory.js';
+import { type Snapshot } from './dashboard-snapshot.js';
+import type { MemoryQuery } from './dashboard-params.js';
+import type { MemoryDetail, MemoryPage, Overview, ProjectDetail, SearchResult } from './dashboard-types.js';
+/** The overview of one snapshot, built once and reused until the snapshot is replaced. */
+export declare function buildOverview(snap: Snapshot): Overview;
+/** Summary and scatter for one project key, or null when the key is unknown. */
+export declare function buildProjectDetail(snap: Snapshot, key: string): ProjectDetail | null;
+/** One page of a project's memories under the query's sort and filters, or null when the key is unknown. */
+export declare function buildMemoryPage(snap: Snapshot, key: string, query: MemoryQuery): MemoryPage | null;
+/** Substring search over content and tags across every project; it reads the snapshot and never touches recall. */
+export declare function buildSearch(snap: Snapshot, text: string): SearchResult;
+/** Full detail read fresh from the store, never from the snapshot, so the drawer is current inside the coalescing window. */
+export declare function buildMemoryDetail(hippoRoot: string, tenantId: string, entry: MemoryEntry, snapshotId: number, nowMs: number, embedded: boolean): MemoryDetail;
+//# sourceMappingURL=dashboard-queries.d.ts.map

package/dist/dashboard-queries.js

@@ -0,0 +1,355 @@
+// Read models over a snapshot: overview, project, memory page, search, and the fresh single-memory detail.
+import { calculateStrength } from './memory.js';
+import { listMemoryConflicts } from './store/conflicts.js';
+import { readEntry } from './store/entry-reads.js';
+import { BANDS, DAY_MS, LAYERS, isLiveMemory, memoryFacts, projectIdentity, } from './dashboard-snapshot.js';
+const SERIES_DAYS = 90;
+/** The server words each delta for this range; the client re-slices the series for 7d and 90d. */
+const DELTA_DAYS = 30;
+const POINTS_MAX = 4_000;
+const GRID_COLS = 64;
+const GRID_ROWS = 32;
+const NAME_MATCHES = 3;
+function round1(value) {
+    return Math.round(value * 10) / 10;
+}
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+/** Cumulative counts at 91 daily points, oldest first: point 0 is the base at the window start, point 90 is now. */
+function cumulativeSeries(times, nowMs) {
+    const days = Array.from({ length: SERIES_DAYS + 1 }, () => 0);
+    let base = 0;
+    for (const t of times) {
+        const ago = Math.floor((nowMs - t) / DAY_MS);
+        if (ago >= SERIES_DAYS)
+            base++;
+        else
+            days[SERIES_DAYS - Math.max(0, ago)]++;
+    }
+    let running = base;
+    return days.map((n) => (running += n));
+}
+function addedWithin(series) {
+    return series[SERIES_DAYS] - series[SERIES_DAYS - DELTA_DAYS];
+}
+function pct(share) {
+    return `${(share * 100).toFixed(1)}%`;
+}
+function plural(n, one, many) {
+    return `${n} ${n === 1 ? one : many}`;
+}
+/** Named projects by size, then Global, then Unassigned, as the treemap orders them. */
+function orderedProjects(snap) {
+    const rank = (p) => (p.summary.kind === 'project' ? 0 : p.summary.kind === 'global' ? 1 : 2);
+    return [...snap.projects].sort((a, b) => rank(a) - rank(b) || b.summary.live - a.summary.live || (a.summary.name < b.summary.name ? -1 : 1));
+}
+function buildKpis(snap, projects) {
+    const total = snap.facts.length;
+    const named = projects.filter((p) => p.summary.kind === 'project');
+    const totalSeries = cumulativeSeries(snap.facts.map((f) => f.createdMs), snap.nowMs);
+    const projectSeries = cumulativeSeries(named.map((p) => p.firstCreatedMs), snap.nowMs);
+    const atRisk = projects.reduce((sum, p) => sum + p.summary.atRisk, 0);
+    const weakNow = snap.facts.reduce((sum, f) => sum + (f.strength < 0.2 ? 1 : 0), 0);
+    const withConflicts = projects.filter((p) => p.summary.openConflicts > 0).length;
+    const embedded = snap.embeddingCoverage === null ? 0 : Math.round(snap.embeddingCoverage * total);
+    return [
+        {
+            id: 'total', label: 'Total memories', value: total, series: totalSeries,
+            delta: `+${addedWithin(totalSeries)} created in the last ${DELTA_DAYS}d`,
+        },
+        {
+            id: 'projects', label: 'Projects', value: named.length, series: projectSeries,
+            delta: `+${addedWithin(projectSeries)} new in ${DELTA_DAYS}d`,
+        },
+        {
+            id: 'atRiskShare', label: 'At-risk share, 30d', value: total > 0 ? atRisk / total : 0, series: null,
+            delta: `${pct(total > 0 ? weakNow / total : 0)} now at strength under 0.2`,
+        },
+        {
+            id: 'openConflicts', label: 'Open conflicts', value: snap.openConflicts, series: null,
+            delta: `in ${plural(withConflicts, 'project', 'projects')}`,
+        },
+        {
+            id: 'embeddingCoverage', label: 'Embedding coverage', value: snap.embeddingCoverage ?? 0, series: null,
+            delta: snap.embeddingCoverage === null ? 'no vector table yet' : `${total - embedded} not embedded`,
+        },
+    ];
+}
+function topKeys(projects, count, score) {
+    return projects
+        .filter((p) => score(p) > 0)
+        .sort((a, b) => score(b) - score(a) || b.summary.live - a.summary.live || (a.summary.key < b.summary.key ? -1 : 1))
+        .slice(0, count)
+        .map((p) => p.summary.key);
+}
+/** The overview of one snapshot, built once and reused until the snapshot is replaced. */
+export function buildOverview(snap) {
+    if (snap.memo.overview !== null)
+        return snap.memo.overview;
+    const ordered = orderedProjects(snap);
+    const overview = {
+        snapshotId: snap.id,
+        generatedAt: new Date(snap.nowMs).toISOString(),
+        total: snap.facts.length,
+        excluded: snap.excluded,
+        embeddingCoverage: snap.embeddingCoverage,
+        kpis: buildKpis(snap, ordered),
+        projects: ordered.map((p) => p.summary),
+        mostAtRisk: topKeys(ordered, 5, (p) => p.summary.atRisk),
+        mostConflicts: topKeys(ordered, 4, (p) => p.summary.openConflicts),
+    };
+    snap.memo.overview = overview;
+    return overview;
+}
+function buildScatter(snap, project) {
+    const cached = snap.memo.scatter.get(project.summary.key);
+    if (cached)
+        return cached;
+    let maxAge = 0;
+    for (const i of project.members)
+        maxAge = Math.max(maxAge, snap.facts[i].ageDays);
+    const maxAgeDays = Math.max(1, Math.ceil(maxAge));
+    let scatter;
+    if (project.members.length <= POINTS_MAX) {
+        const points = [];
+        const ids = [];
+        for (const i of project.members) {
+            const f = snap.facts[i];
+            points.push([round1(f.ageDays), round3(f.strength), f.layer, f.band]);
+            ids.push(f.id);
+        }
+        scatter = { mode: 'points', maxAgeDays, points, ids };
+    }
+    else {
+        const cells = [[], [], [], []];
+        for (const layer of cells)
+            for (let k = 0; k < GRID_COLS * GRID_ROWS; k++)
+                layer.push(0);
+        const maxLog = Math.log10(maxAgeDays + 1);
+        for (const i of project.members) {
+            const f = snap.facts[i];
+            const col = Math.min(GRID_COLS - 1, Math.floor((Math.log10(f.ageDays + 1) / maxLog) * GRID_COLS));
+            const row = Math.min(GRID_ROWS - 1, Math.floor(f.strength * GRID_ROWS));
+            cells[f.layer][row * GRID_COLS + col]++;
+        }
+        scatter = { mode: 'grid', maxAgeDays, cols: GRID_COLS, rows: GRID_ROWS, cells };
+    }
+    snap.memo.scatter.set(project.summary.key, scatter);
+    return scatter;
+}
+/** Summary and scatter for one project key, or null when the key is unknown. */
+export function buildProjectDetail(snap, key) {
+    const project = snap.byKey.get(key);
+    if (!project)
+        return null;
+    return { snapshotId: snap.id, summary: project.summary, scatter: buildScatter(snap, project) };
+}
+function numericSort(sort) {
+    switch (sort) {
+        case 'layer': return (f) => f.layer;
+        case 'strength': return (f) => f.strength;
+        case 'retrievals': return (f) => f.retrievals;
+        case 'last': return (f) => f.lastRetrievedDays;
+        case 'age': return (f) => f.ageDays;
+        case 'confidence': return (f) => f.confidenceRank;
+        case 'content':
+        case 'scope': return null;
+    }
+}
+function comparator(facts, sort, dir) {
+    const sign = dir === 'asc' ? 1 : -1;
+    const tie = (a, b) => (facts[a].id < facts[b].id ? -1 : facts[a].id > facts[b].id ? 1 : 0);
+    const num = numericSort(sort);
+    if (num)
+        return (a, b) => (num(facts[a]) - num(facts[b])) * sign || tie(a, b);
+    // Content and scope compare precomputed strings with `<`; localeCompare per pair is far slower at 50k rows.
+    const text = sort === 'content' ? (f) => f.lower : (f) => f.scope ?? '';
+    return (a, b) => {
+        const x = text(facts[a]);
+        const y = text(facts[b]);
+        return (x < y ? -sign : x > y ? sign : 0) || tie(a, b);
+    };
+}
+function sortedMembers(snap, project, sort, dir) {
+    const key = `${project.summary.key}|${sort}|${dir}`;
+    const hit = snap.memo.sorted.get(key);
+    if (hit)
+        return hit;
+    const sorted = Int32Array.from(project.members).sort(comparator(snap.facts, sort, dir));
+    snap.memo.sorted.set(key, sorted);
+    return sorted;
+}
+function bucket(value) {
+    return value >= 0.5 ? 0 : value >= 0.2 ? 1 : 2;
+}
+function filterMembers(snap, sorted, query) {
+    const layerOn = [false, false, false, false];
+    for (const l of query.layers)
+        layerOn[l] = true;
+    const { brush, q } = query;
+    const kept = new Int32Array(sorted.length);
+    let n = 0;
+    const counts = { all: 0, risk: 0, pinned: 0, conflict: 0 };
+    const decay = { now: [0, 0, 0], in7d: [0, 0, 0], in30d: [0, 0, 0], pinned: 0 };
+    for (const i of sorted) {
+        const f = snap.facts[i];
+        if (!layerOn[f.layer])
+            continue;
+        if (f.ageDays < brush.amin || f.ageDays > brush.amax || f.strength < brush.smin || f.strength > brush.smax)
+            continue;
+        if (q !== null && !f.lower.includes(q) && !f.tagsLower.includes(q))
+            continue;
+        kept[n++] = i;
+        decay.now[bucket(f.strength)]++;
+        decay.in7d[bucket(f.strength7d)]++;
+        decay.in30d[bucket(f.strength30d)]++;
+        if (f.pinned) {
+            decay.pinned++;
+            counts.pinned++;
+        }
+        if (f.band === 3)
+            counts.risk++;
+        if (f.inConflict)
+            counts.conflict++;
+        counts.all++;
+    }
+    return { idx: kept.subarray(0, n), counts, decay, byChip: new Map() };
+}
+function filteredSet(snap, project, query) {
+    const { brush } = query;
+    const key = [
+        project.summary.key, query.sort, query.dir, query.layers.join(''),
+        brush.amin, brush.amax, brush.smin, brush.smax, query.q ?? '',
+    ].join('|');
+    const hit = snap.memo.filtered.get(key);
+    if (hit)
+        return hit;
+    const set = filterMembers(snap, sortedMembers(snap, project, query.sort, query.dir), query);
+    snap.memo.filtered.set(key, set);
+    return set;
+}
+function chipMembers(snap, set, chip) {
+    if (chip === 'all')
+        return set.idx;
+    const hit = set.byChip.get(chip);
+    if (hit)
+        return hit;
+    const pick = (f) => (chip === 'risk' ? f.band === 3 : chip === 'pinned' ? f.pinned : f.inConflict);
+    const out = set.idx.filter((i) => pick(snap.facts[i]));
+    set.byChip.set(chip, out);
+    return out;
+}
+function toRow(f) {
+    return {
+        id: f.id,
+        content: f.head,
+        truncated: f.truncated,
+        layer: LAYERS[f.layer],
+        band: BANDS[f.band],
+        strength: round3(f.strength),
+        retrievals: f.retrievals,
+        lastRetrievedDays: round1(f.lastRetrievedDays),
+        ageDays: round1(f.ageDays),
+        confidence: f.confidence,
+        scope: f.scope,
+        pinned: f.pinned,
+        wrong: f.wrong,
+        inConflict: f.inConflict,
+    };
+}
+/** One page of a project's memories under the query's sort and filters, or null when the key is unknown. */
+export function buildMemoryPage(snap, key, query) {
+    const project = snap.byKey.get(key);
+    if (!project)
+        return null;
+    const set = filteredSet(snap, project, query);
+    const shown = chipMembers(snap, set, query.chip);
+    const rows = [];
+    for (let k = query.offset; k < Math.min(shown.length, query.offset + query.limit); k++) {
+        rows.push(toRow(snap.facts[shown[k]]));
+    }
+    const decay = set.decay;
+    return { snapshotId: snap.id, total: shown.length, offset: query.offset, limit: query.limit, counts: set.counts, decay, rows };
+}
+/** Substring search over content and tags across every project; it reads the snapshot and never touches recall. */
+export function buildSearch(snap, text) {
+    const needle = text.toLowerCase();
+    const perProject = Array.from({ length: snap.projects.length }, () => 0);
+    let total = 0;
+    for (const f of snap.facts) {
+        if (f.lower.includes(needle) || f.tagsLower.includes(needle)) {
+            perProject[f.project]++;
+            total++;
+        }
+    }
+    const hits = {};
+    snap.projects.forEach((p, i) => {
+        if (perProject[i] > 0)
+            hits[p.summary.key] = perProject[i];
+    });
+    const nameMatches = snap.projects
+        .filter((p) => p.summary.name.toLowerCase().includes(needle))
+        .sort((a, b) => b.summary.live - a.summary.live)
+        .slice(0, NAME_MATCHES)
+        .map((p) => ({ key: p.summary.key, name: p.summary.name, live: p.summary.live }));
+    return { snapshotId: snap.id, q: text, total, hits, nameMatches };
+}
+function openConflictsOf(hippoRoot, tenantId, entry, nowMs) {
+    const out = [];
+    for (const c of listMemoryConflicts(hippoRoot, 'open', tenantId)) {
+        if (c.memory_a_id !== entry.id && c.memory_b_id !== entry.id)
+            continue;
+        const otherId = c.memory_a_id === entry.id ? c.memory_b_id : c.memory_a_id;
+        const other = readEntry(hippoRoot, otherId, tenantId);
+        if (!other || !isLiveMemory(other))
+            continue;
+        out.push({
+            id: c.id,
+            reason: c.reason,
+            score: c.score,
+            other: {
+                id: other.id,
+                content: other.content,
+                strength: round3(calculateStrength(other, new Date(nowMs))),
+                retrievals: other.retrieval_count,
+            },
+        });
+    }
+    return out;
+}
+/** Full detail read fresh from the store, never from the snapshot, so the drawer is current inside the coalescing window. */
+export function buildMemoryDetail(hippoRoot, tenantId, entry, snapshotId, nowMs, embedded) {
+    const f = memoryFacts(entry, nowMs);
+    const project = projectIdentity(entry.origin_project);
+    return {
+        snapshotId,
+        id: entry.id,
+        content: entry.content,
+        layer: LAYERS[f.layer],
+        band: BANDS[f.band],
+        tags: entry.tags,
+        strength: round3(f.strength),
+        strength7d: round3(f.strength7d),
+        strength30d: round3(f.strength30d),
+        halfLifeDays: entry.half_life_days,
+        retrievals: entry.retrieval_count,
+        lastRetrieved: entry.last_retrieved,
+        created: entry.created,
+        ageDays: round1(f.ageDays),
+        schemaFit: entry.schema_fit,
+        valence: entry.emotional_valence,
+        confidence: f.confidence,
+        agedOut: f.agedOut,
+        pinned: entry.pinned,
+        wrong: f.wrong,
+        projectKey: project.key,
+        projectName: project.name,
+        scope: entry.scope,
+        tenant: entry.tenantId,
+        kind: entry.kind,
+        embedded,
+        conflicts: openConflictsOf(hippoRoot, tenantId, entry, nowMs),
+    };
+}
+//# sourceMappingURL=dashboard-queries.js.map