hippo-memory 1.69.0 → 1.71.0

package/dist/{project-identity.js → core/project-identity.js}

@@ -1,12 +1,13 @@
-import { envHippoHome, envXdgDataHome } from './env.js';
+import { envHippoHome, envXdgDataHome } from '../util/env.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { BadRequestError } from './api-errors.js';
 import { isSharedStore, loadConfig } from './config.js';
-import { MAX_ID_LEN } from './http-util.js';
-import { log } from './log.js';
+import { MAX_ID_LEN } from '../util/http-util.js';
+import { errorMessage, log } from '../util/log.js';
 import { originRemoteId, projectFileId } from './project-remote.js';
+import { realpathOrResolve } from '../util/real-path.js';
 const MAX_WALK_DEPTH = 64;
 const identityCache = new Map();
 let remoteSwitch = null;
@@ -22,7 +23,8 @@ function remoteRuleOn() {
         remoteSwitch = { globalRoot, on: loadConfig(globalRoot).projectIdentity.remote };
     return remoteSwitch.on;
 }
-/** The id a root names itself by plus every rung that resolves; only the root's own `.git` is read, so a store nested in another checkout keeps its folder name. */
+/** The id a root names itself by plus every rung that resolves; only the root's own
+ * `.git` is read, so a store nested in another checkout keeps its folder name. */
 function namesAt(root, legacyName) {
     const fileId = projectFileId(root);
     const remoteId = originRemoteId(root);
@@ -30,19 +32,6 @@ function namesAt(root, legacyName) {
     const aliases = [...new Set([fileId, remoteId, legacyName])].filter((n) => n !== null && n !== name);
     return aliases.length > 0 ? { name, aliases } : { name };
 }
-/**
- * Canonicalize a path via realpath, falling back to path.resolve when the
- * path does not exist or realpath fails (mirrors importers.ts).
- */
-export function realpathOrResolve(p) {
-    try {
-        return fs.realpathSync.native(p);
-    }
-    catch (err) {
-        log.debug(`project identity: realpath fell back to resolve for ${p}: ${err instanceof Error ? err.message : String(err)}`);
-        return path.resolve(p);
-    }
-}
 /** Compare two canonical paths, case-insensitively on Windows. */
 function samePath(a, b) {
     if (process.platform === 'win32')
@@ -60,22 +49,18 @@ function isUnder(child, parent) {
     }
     return false;
 }
-/** A `.hippo` marker must be a DIRECTORY (a store) - a stray file named
- *  `.hippo` must not turn its parent into a project. `.git` stays existsSync
- *  because worktrees legitimately use a `.git` FILE. */
+/** A `.hippo` marker must be a DIRECTORY (a store), so a stray file named `.hippo` cannot make its parent a project;
+ *  `.git` stays existsSync because worktrees use a `.git` FILE. */
 function isDirectoryAt(p) {
     try {
         return fs.statSync(p).isDirectory();
     }
     catch (err) {
-        log.debug(`project identity: no marker at ${p}: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`project identity: no marker at ${p}: ${errorMessage(err)}`);
         return false;
     }
 }
-/**
- * Resolve the project identity for a working directory.
- * Defaults to process.cwd(). Results are cached per resolved input path.
- */
+/** Resolves the project identity for a working directory (default process.cwd()); results are cached per resolved input path. */
 export function resolveProjectIdentity(cwd, opts) {
     const startInput = path.resolve(cwd ?? process.cwd());
     const cacheable = !opts?.homeDir && !opts?.stopDir;
@@ -108,7 +93,8 @@ export function resolveProjectIdentity(cwd, opts) {
         identityCache.set(startInput, identity);
     return identity;
 }
-/** The repo name a linked worktree shares with its main checkout (`repo.git` or `repo/.bare` for a bare repo), so one repo is one project; null for any other checkout. */
+/** The repo name a linked worktree shares with its main checkout (`repo.git` or
+ * `repo/.bare` for a bare repo), so one repo is one project; null for any other checkout. */
 function linkedWorktreeRepoName(gitRoot, home) {
     const marker = path.join(gitRoot, '.git');
     if (!fs.existsSync(marker) || isDirectoryAt(marker))
@@ -184,7 +170,8 @@ export function projectNames(project) {
 // Each project name is matched against every candidate row, so the caller's list stays short.
 export const MAX_PROJECT_ALIASES = 10;
 export const MCP_PROJECT_SCOPED_HEADER = 'X-Hippo-Project-Scoped';
-/** Refuses a caller's project that is blank (it would stamp user-global), past the caps, or unlike the resolver's ids: rows match verbatim, so a rewrite would split a project. Inner spaces pass, since a checkout with no remote is named by its folder. */
+/** Refuses a caller's project that is blank (it would stamp user-global), past the caps, or unlike the resolver's ids: rows match
+ * verbatim, so a rewrite would split a project. Inner spaces pass, since a checkout with no remote is named by its folder. */
 export function assertCallerProject(project) {
     const { name, aliases = [] } = project;
     if (name.trim() === '')
@@ -202,14 +189,8 @@ export function assertCallerProject(project) {
 export function originInSql(names, column = 'origin_project') {
     return names.length === 0 ? '0' : `${column} IN (${names.map(() => '?').join(', ')})`;
 }
-/**
- * v39 memory scope isolation: classify a memory's origin_project against the
- * active project. An empty current id means the session is not in a project
- * (home dir or markerless cwd) - everything is in scope there, matching
- * pre-isolation behavior. NULL/undefined origin means no known project (a legacy
- * row, or a shared-store write that named none) and is treated as cross-project
- * (deny by default) - the safe direction for a security partition.
- */
+/** Classifies a memory's origin_project against the active project. An empty current id (home or markerless cwd) puts everything in scope;
+ * NULL/undefined origin (legacy row, or a shared-store write naming none) counts as cross-project: deny by default for a security partition. */
 export function classifyOriginProject(origin, current) {
     if (projectId(current) === '')
         return 'project';
@@ -219,12 +200,8 @@ export function classifyOriginProject(origin, current) {
         return 'user-global';
     return projectNames(current).includes(origin) ? 'project' : 'cross-project';
 }
-/**
- * The global Hippo store directory, resolved the same way shared.ts does:
- * $HIPPO_HOME > $XDG_DATA_HOME/hippo > ~/.hippo. Lives here (leaf module) so
- * db.ts migrations can use it without importing shared.ts (store.ts cycle);
- * shared.getGlobalRoot delegates to this.
- */
+/** The global Hippo store directory ($HIPPO_HOME > $XDG_DATA_HOME/hippo > ~/.hippo); getGlobalRoot (sharing/global-store.ts) returns it.
+ * Leaf module so store migrations can use it without importing sharing/ (store cycle). */
 export function resolveGlobalRootDir() {
     const hippoHome = envHippoHome();
     if (hippoHome)
@@ -234,23 +211,13 @@ export function resolveGlobalRootDir() {
         return path.join(xdgData, 'hippo');
     return path.join(os.homedir(), '.hippo');
 }
-/**
- * True when `p` IS the global store root. Used by the v39 migration so a
- * global store whose parent chain happens to contain `.git`/`.hippo`
- * (git-managed HIPPO_HOME, dotfiles setups) still backfills as user-global
- * ('') instead of being stamped with the surrounding repo's name - which
- * would hide the user's entire global corpus from every project.
- */
+/** True when `p` IS the global store root, so a global store whose parent chain contains `.git`/`.hippo` (git-managed HIPPO_HOME) still backfills as
+ * user-global ('') instead of being stamped with the surrounding repo's name, which would hide the global corpus from every project. */
 export function isGlobalStoreRoot(p) {
     return samePath(realpathOrResolve(path.resolve(p)), realpathOrResolve(resolveGlobalRootDir()));
 }
-/**
- * Parse a memory's origin from its provenance `source` string, mirroring the
- * v39 migration's evidence rules: `shared:<project>:<ts>` and
- * `promoted:<localRoot>` identify the owning project; the user home dir's
- * basename maps to '' (user-global). Returns null when the source carries no
- * origin evidence. Pure string logic - recorded paths may no longer exist.
- */
+/** Parses a memory's origin from its provenance `source`: `shared:<project>:<ts>` and `promoted:<localRoot>` name the owning project; the home dir basename
+ * maps to '' (user-global). Returns null without origin evidence. Pure string logic, since recorded paths may no longer exist. */
 export function originFromSource(source, homeName) {
     if (!source)
         return null;

package/dist/{project-remote.js → core/project-remote.js}

@@ -2,14 +2,15 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { isObjectLike, isStringValue } from './capture-contract.js';
-import { log } from './log.js';
+import { errorMessage, log } from '../util/log.js';
 /** The config file git reads for a checkout: `.git/config`, a linked worktree's `<commondir>/config`, a submodule's `<gitdir>/config`. */
 export function gitConfigPath(gitRoot) {
     const marker = path.join(gitRoot, '.git');
     try {
-        if (fs.statSync(marker).isDirectory())
+        const pointer = gitFilePointer(marker);
+        if (pointer === null)
             return path.join(marker, 'config');
-        const gitDir = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(marker, 'utf8'))?.[1]?.trim();
+        const gitDir = /^gitdir:\s*(.+)$/m.exec(pointer)?.[1]?.trim();
         if (!gitDir)
             return null;
         const linkDir = path.resolve(gitRoot, gitDir);
@@ -19,10 +20,20 @@ export function gitConfigPath(gitRoot) {
         return path.join(path.resolve(linkDir, fs.readFileSync(commondir, 'utf8').trim()), 'config');
     }
     catch (err) {
-        log.debug(`project remote: no git config for ${gitRoot}: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`project remote: no git config for ${gitRoot}: ${errorMessage(err)}`);
         return null;
     }
 }
+/** The text of a `.git` file, or null when `.git` is a folder; one descriptor answers both, so the path cannot change in between. */
+function gitFilePointer(marker) {
+    const fd = fs.openSync(marker, 'r');
+    try {
+        return fs.fstatSync(fd).isDirectory() ? null : fs.readFileSync(fd, 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 /** One config value with git's quoting: `"` toggles quoting, backslash escapes, and an unquoted `#` or `;` starts a comment. */
 function configValue(raw) {
     let out = '';
@@ -111,7 +122,7 @@ export function originRemoteId(gitRoot) {
         return url === null ? null : normaliseRemote(url);
     }
     catch (err) {
-        log.debug(`project remote: ${file} not read: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`project remote: ${file} not read: ${errorMessage(err)}`);
         return null;
     }
 }
@@ -131,7 +142,7 @@ export function projectFileId(root) {
         log.warn(`${file}: "id" must be a non-empty string with no colon, slash or spaces; using the remote or folder name instead`);
     }
     catch (err) {
-        log.warn(`${file} not read: ${err instanceof Error ? err.message : String(err)}; using the remote or folder name instead`);
+        log.warn(`${file} not read: ${errorMessage(err)}; using the remote or folder name instead`);
     }
     return null;
 }

package/dist/{prompt-recall.js → core/prompt-recall.js}

@@ -1,5 +1,5 @@
 /** Recall gated on the hook prompt, not the five newest memories (pure, no I/O). */
-import { tokenize } from './tokenize.js';
+import { tokenize } from '../util/tokenize.js';
 import { STOP_WORDS } from './memory-quality.js';
 // Latency bound, not tuned: fixed in the prereg regardless of gate config.
 export const PROMPT_RECALL_MAX_CHARS = 4000;

package/dist/core/raw-append-only.d.ts

@@ -0,0 +1,5 @@
+/** The refusal a delete of a raw row gets; a plain Error subclass, so it joins no HTTP status family. */
+export declare class RawAppendOnlyError extends Error {
+    constructor(cause: Error);
+}
+//# sourceMappingURL=raw-append-only.d.ts.map

package/dist/core/raw-append-only.js

@@ -0,0 +1,7 @@
+/** The refusal a delete of a raw row gets; a plain Error subclass, so it joins no HTTP status family. */
+export class RawAppendOnlyError extends Error {
+    constructor(cause) {
+        super('raw is append-only', { cause });
+    }
+}
+//# sourceMappingURL=raw-append-only.js.map

package/dist/{salience.d.ts → core/salience.d.ts}

@@ -1,10 +1,4 @@
-/**
- * Salience gate — decides at memory creation time whether content is worth
- * storing at full strength, should start weakened, or should be skipped.
- *
- * Inspired by the biological salience network (anterior insula + dACC):
- * not everything that enters working memory deserves long-term storage.
- */
+/** Salience gate: decides at memory creation whether content is stored at full strength, starts weakened, or is skipped. */
 import type { MemoryEntry } from './memory.js';
 export type SalienceDecision = 'store' | 'skip' | 'start_weak';
 export interface SalienceResult {

package/dist/{salience.js → core/salience.js}

@@ -1,12 +1,15 @@
-/**
- * Salience gate — decides at memory creation time whether content is worth
- * storing at full strength, should start weakened, or should be skipped.
- *
- * Inspired by the biological salience network (anterior insula + dACC):
- * not everything that enters working memory deserves long-term storage.
- */
-import { textOverlap } from './tokenize.js';
-import { duplicateKey, heldTextKeys } from './same-text.js';
+/** Salience gate: decides at memory creation whether content is stored at full strength, starts weakened, or is skipped. */
+import { textOverlap } from '../util/tokenize.js';
+import { duplicateKey, heldTextKeys } from '../util/same-text.js';
+// Each store or skip reason carries a score; a novel memory adds bonuses for structure and length.
+const REPEAT_ERROR_SCORE = 0.3;
+const ERROR_DESPITE_OVERLAP_SCORE = 0.7;
+const NEAR_DUPLICATE_SCORE = 0.5;
+const DUPLICATE_SCORE = 0.1;
+const NOVEL_ERROR_SCORE = 0.9;
+const NOVEL_BASE_SCORE = 0.5;
+const STRUCTURED_TAGS_BONUS = 0.15;
+const LENGTH_BONUS = 0.1;
 const DEFAULTS = {
     recentWindow: 20,
     overlapThreshold: 0.6,
@@ -33,34 +36,40 @@ export function computeSalience(content, tags, recentMemories, options = {}) {
                 return {
                     decision: 'start_weak',
                     reason: `repeat_error (${recentErrors} recent errors, overlap ${(duplicateMatch.overlap * 100).toFixed(0)}% with ${duplicateMatch.matchId})`,
-                    score: 0.3,
+                    score: REPEAT_ERROR_SCORE,
                 };
             }
-            return { decision: 'store', reason: 'error_despite_overlap', score: 0.7 };
+            return { decision: 'store', reason: 'error_despite_overlap', score: ERROR_DESPITE_OVERLAP_SCORE };
         }
-        // A near-duplicate may be a changed value (port 8080 then 8081), so only the same text is skipped.
-        const key = duplicateKey(trimmed);
-        const same = window.find((m) => heldTextKeys(m).includes(key));
-        if (!same) {
-            return {
-                decision: 'store',
-                reason: `near_duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
-                score: 0.5,
-            };
-        }
-        return { decision: 'skip', reason: `duplicate (same text as ${same.id})`, score: 0.1 };
+        return judgeOverlappingNonError(trimmed, window, duplicateMatch);
     }
     if (isError) {
-        return { decision: 'store', reason: 'error_novel', score: 0.9 };
+        return { decision: 'store', reason: 'error_novel', score: NOVEL_ERROR_SCORE };
+    }
+    return scoreNovel(trimmed, tags);
+}
+function judgeOverlappingNonError(trimmed, window, duplicateMatch) {
+    // A near-duplicate may be a changed value (port 8080 then 8081), so only the same text is skipped.
+    const key = duplicateKey(trimmed);
+    const same = window.find((m) => heldTextKeys(m).includes(key));
+    if (!same) {
+        return {
+            decision: 'store',
+            reason: `near_duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
+            score: NEAR_DUPLICATE_SCORE,
+        };
     }
+    return { decision: 'skip', reason: `duplicate (same text as ${same.id})`, score: DUPLICATE_SCORE };
+}
+function scoreNovel(trimmed, tags) {
     const hasStructuredTags = tags.some(t => t.startsWith('speaker:') || t.startsWith('topic:') || t.startsWith('scope:'));
-    let score = 0.5;
+    let score = NOVEL_BASE_SCORE;
     if (hasStructuredTags)
-        score += 0.15;
+        score += STRUCTURED_TAGS_BONUS;
     if (trimmed.length > 100)
-        score += 0.1;
+        score += LENGTH_BONUS;
     if (trimmed.length > 300)
-        score += 0.1;
+        score += LENGTH_BONUS;
     return { decision: 'store', reason: 'novel', score: Math.min(score, 1.0) };
 }
 function findBestOverlap(content, memories) {

package/dist/{search/types.d.ts → core/search-types.d.ts}

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from '../memory.js';
+import type { MemoryEntry } from './memory.js';
 export declare const DEFAULT_RECALL_BUDGET = 4000;
 export declare const DEFAULT_LOCAL_BUMP = 1.2;
 /** One score mutation applied after candidate generation; allocated only under `recall --why` or `RecallOpts.explain`. */
@@ -90,4 +90,4 @@ export interface ScoreBreakdown {
     /** 1.05 if a summary was rebuilt within 7 days; 1.0 otherwise. */
     summaryFreshnessBoost?: number;
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=search-types.d.ts.map

package/dist/{search/types.js → core/search-types.js}

@@ -1,4 +1,4 @@
 export const DEFAULT_RECALL_BUDGET = 4000;
 // Local memories outrank global ones by this factor; getContext applies it as a 1/x global discount.
 export const DEFAULT_LOCAL_BUMP = 1.2;
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=search-types.js.map

package/dist/core/session-digest-row.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryEntry } from './memory.js';
+export declare const SESSION_DIGEST_TAG = "session-digest";
+/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
+export declare function isSessionDigestRow(entry: Pick<MemoryEntry, 'source' | 'tags' | 'extracted_from'>): boolean;
+//# sourceMappingURL=session-digest-row.d.ts.map

package/dist/core/session-digest-row.js

@@ -0,0 +1,6 @@
+export const SESSION_DIGEST_TAG = 'session-digest';
+/** Facts extracted from a digest and DAG summaries over one inherit its tag, but they are not the digest itself. */
+export function isSessionDigestRow(entry) {
+    return entry.source === SESSION_DIGEST_TAG && entry.tags.includes(SESSION_DIGEST_TAG) && !entry.extracted_from;
+}
+//# sourceMappingURL=session-digest-row.js.map

package/dist/{dashboard-actions.d.ts → dashboard/dashboard-actions.d.ts}

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from './memory.js';
+import type { MemoryEntry } from '../core/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 {

package/dist/{dashboard-actions.js → dashboard/dashboard-actions.js}

@@ -1,9 +1,10 @@
 // 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 { listTouchableConflicts, resolveConflict } from './store/conflicts.js';
-import { readEntry } from './store/entry-reads.js';
-import { writeEntry } from './store/entry-writes.js';
+import * as api from '../api/index.js';
+import { NotFoundError } from '../core/api-errors.js';
+import { RawAppendOnlyError } from '../core/raw-append-only.js';
+import { listTouchableConflicts, 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';
@@ -52,8 +53,7 @@ export function forgetMemory(hippoRoot, tenantId, rawId) {
     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)) {
+        if (err instanceof RawAppendOnlyError) {
             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 };
         }

package/dist/{dashboard-queries.d.ts → dashboard/dashboard-queries.d.ts}

@@ -1,4 +1,4 @@
-import { type MemoryEntry } from './memory.js';
+import { type MemoryEntry } from '../core/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';
@@ -10,6 +10,11 @@ export declare function buildProjectDetail(snap: Snapshot, key: string): Project
 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;
+export interface MemoryDetailOptions {
+    readonly snapshotId: number;
+    readonly nowMs: number;
+    readonly embedded: boolean;
+}
 /** 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;
+export declare function buildMemoryDetail(hippoRoot: string, tenantId: string, entry: MemoryEntry, options: MemoryDetailOptions): MemoryDetail;
 //# sourceMappingURL=dashboard-queries.d.ts.map

package/dist/{dashboard-queries.js → dashboard/dashboard-queries.js}

@@ -1,7 +1,6 @@
 // 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 { calculateStrength } from '../core/memory.js';
+import { loadOpenConflictsOf } from '../store/conflicts.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. */
@@ -297,12 +296,8 @@ export function buildSearch(snap, text) {
 }
 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))
+    for (const { conflict: c, other } of loadOpenConflictsOf(hippoRoot, tenantId, entry.id)) {
+        if (!isLiveMemory(other))
             continue;
         out.push({
             id: c.id,
@@ -319,7 +314,8 @@ function openConflictsOf(hippoRoot, tenantId, entry, nowMs) {
     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) {
+export function buildMemoryDetail(hippoRoot, tenantId, entry, options) {
+    const { snapshotId, nowMs, embedded } = options;
     const f = memoryFacts(entry, nowMs);
     const project = projectIdentity(entry.origin_project);
     return {

package/dist/{dashboard-snapshot.d.ts → dashboard/dashboard-snapshot.d.ts}

@@ -1,13 +1,11 @@
-import { Layer as MemoryLayer, type MemoryEntry } from './memory.js';
-import type { MemoryConflict } from './store/rows.js';
+import { Layer as MemoryLayer, type ConfidenceInputs, type MemoryEntry, type StrengthInputs } from '../core/memory.js';
+import { type DashboardRow, type ExcludedCounts } from '../store/dashboard-reads.js';
+import type { MemoryConflict } from '../store/rows.js';
 import type { Band, ChipCounts, Layer, Overview, ProjectKind, ProjectSummary, ScatterGrid, ScatterPoints } from './dashboard-types.js';
-export declare const DAY_MS = 86400000;
+import { DAY_MS } from '../util/time.js';
+export { DAY_MS };
 export declare const LAYERS: readonly Layer[];
 export declare const BANDS: readonly Band[];
-/** An outside commit rebuilds the snapshot at most this often. */
-export declare const COALESCE_MS = 10000;
-/** Projected strengths track the clock, so the snapshot is rebuilt at least this often. */
-export declare const TTL_MS: number;
 /** The one predicate for "shown on the dashboard": not superseded, not archived, not quarantined. */
 export declare function isLiveMemory(entry: Pick<MemoryEntry, 'superseded_by' | 'kind' | 'scope'>): boolean;
 /** Wire key, display name and kind of a project. */
@@ -34,7 +32,7 @@ export interface MemoryFacts {
     wrong: boolean;
 }
 /** Strength now and at +7d and +30d, band, age and the confidence split for one entry at `nowMs`. */
-export declare function memoryFacts(entry: MemoryEntry, nowMs: number): MemoryFacts;
+export declare function memoryFacts(entry: StrengthInputs & ConfidenceInputs & Pick<MemoryEntry, 'layer'>, nowMs: number): MemoryFacts;
 /** One live memory as the snapshot holds it: numbers and short strings only, never the full entry. */
 export interface Fact {
     id: string;
@@ -116,7 +114,9 @@ export interface SnapshotInput {
     id: number;
     tenantId: string;
     nowMs: number;
-    entries: readonly MemoryEntry[];
+    entries: readonly DashboardRow[];
+    /** Rows counted out before `entries` was read; any entry here that is not live adds to them. */
+    excluded?: ExcludedCounts;
     openConflicts: readonly Pick<MemoryConflict, 'memory_a_id' | 'memory_b_id'>[];
     embeddedIds: ReadonlySet<string> | null;
 }
@@ -133,6 +133,7 @@ export interface SnapshotService {
     embeddedIds(): ReadonlySet<string> | null;
     close(): void;
 }
-/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
+/** Holds one read-only connection for its commit signal (`PRAGMA data_version`) and the
+ * snapshot cache; `now` dates the strength projections, `cacheClock` ages the cache. */
 export declare function createSnapshotService(hippoRoot: string, now: () => number, cacheClock?: () => number): SnapshotService;
 //# sourceMappingURL=dashboard-snapshot.d.ts.map