hippo-memory 1.60.0 → 1.61.0

package/README.md

@@ -769,7 +769,7 @@ hippo watch "npm run build"
 | `hippo wm read --scope <s>` | Read working memory entries |
 | `hippo wm clear --scope <s>` | Clear working memory |
 | `hippo wm flush --scope <s>` | Flush working memory (session end) |
-| `hippo dashboard` | Open web dashboard at localhost:3333 (memory map and card board) |
+| `hippo dashboard` | Open web dashboard at localhost:3333 (memory health by project, and the card board); open the printed URL, which carries a per-start access token |
 | `hippo dashboard --port <n>` | Use custom port |
 | `hippo mcp` | Start MCP server (stdio transport) |
 

package/dist/ablation.js

@@ -84,38 +84,20 @@
  * that mutate these env vars MUST call _resetAblationCacheForTests() in BOTH
  * beforeEach AND afterEach.
  */
+import { envAblateDecay, envAblateOutcome, envAblateOutcomeFast, envAblateOutcomeSlow, envAblateRecallBoost, envAblateRecency, envEvalRecencyDays, envFakeNowMs, } from './env.js';
 let _cache;
-function isTruthy(value) {
-    return value === '1' || value === 'true';
-}
 function readFlags() {
     if (_cache !== undefined)
         return _cache;
-    const outcomeBoth = isTruthy(process.env.HIPPO_ABLATE_OUTCOME);
-    let fakeNowMs = null;
-    const rawNow = process.env.HIPPO_FAKE_NOW;
-    if (rawNow !== undefined && rawNow !== '') {
-        // STRICT canonical form only: exactly what Date.prototype.toISOString
-        // emits (YYYY-MM-DDTHH:mm:ss.sssZ), verified by ROUND-TRIP equality.
-        // Two codex P2s drove this: (1) Date.parse accepts junk like '1' or
-        // locale-dependent '06/11/2026'; (2) a regex alone still admits
-        // rolled-over dates ('2026-02-31T...Z' silently becomes March 3). A
-        // value that does not round-trip byte-identical falls back to the real
-        // clock, exactly as documented.
-        const parsed = Date.parse(rawNow);
-        if (Number.isFinite(parsed) && new Date(parsed).toISOString() === rawNow) {
-            fakeNowMs = parsed;
-        }
-    }
-    const recencyDays = Number(process.env.HIPPO_EVAL_RECENCY_DAYS);
+    const outcomeBoth = envAblateOutcome();
     _cache = {
-        decay: isTruthy(process.env.HIPPO_ABLATE_DECAY),
-        recallBoost: isTruthy(process.env.HIPPO_ABLATE_RECALL_BOOST),
-        outcomeSlow: outcomeBoth || isTruthy(process.env.HIPPO_ABLATE_OUTCOME_SLOW),
-        outcomeFast: outcomeBoth || isTruthy(process.env.HIPPO_ABLATE_OUTCOME_FAST),
-        recency: isTruthy(process.env.HIPPO_ABLATE_RECENCY),
-        recencyDays: Number.isFinite(recencyDays) && recencyDays > 0 ? recencyDays : null,
-        fakeNowMs,
+        decay: envAblateDecay(),
+        recallBoost: envAblateRecallBoost(),
+        outcomeSlow: outcomeBoth || envAblateOutcomeSlow(),
+        outcomeFast: outcomeBoth || envAblateOutcomeFast(),
+        recency: envAblateRecency(),
+        recencyDays: envEvalRecencyDays(),
+        fakeNowMs: envFakeNowMs(),
     };
     return _cache;
 }

package/dist/agent-memories/apply.js

@@ -5,7 +5,10 @@ import { gatedWrite } from '../gated-write.js';
 import { Layer, calculateStrength, createMemory } from '../memory.js';
 import { findRejectedValue, rejectionDigest } from '../rejection.js';
 import { redactSecretsStrict } from '../secret-detect.js';
-import { deleteEntryRowInTx, markSummaryDirtyInTx, selectLiveEntriesBySourcePrefix, setEntryTagsInTx, stampOriginProject } from '../store.js';
+import { stampOriginProject } from '../store/entry-row.js';
+import { deleteEntryRowInTx, setEntryTagsInTx } from '../store/entry-writes.js';
+import { selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
+import { markSummaryDirtyInTx } from '../summary-dirty.js';
 import { itemHash } from './keys.js';
 import { planContainer } from './plan.js';
 import { emptyTally } from './report.js';

package/dist/agent-memories/claude-code.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { realpathOrResolve } from '../project-identity.js';
 import { isStringValue } from '../capture-contract.js';
-import { isJsonObject } from '../hooks.js';
+import { isJsonObject } from '../hooks/shared.js';
 import { expandHome, frontmatterField, itemTime, readTextFile, splitFrontmatter } from './files.js';
 import { markdownNotes, readFolderStore, uniqueFolders } from './folder-store.js';
 import { gitLayout } from './git.js';

package/dist/agent-memories/codex.js

@@ -1,7 +1,7 @@
 // Codex CLI's memory_summary.md, the one memory file Codex puts in its prompt, read as a single text-keyed file.
 import fs from 'node:fs';
 import path from 'node:path';
-import { codexHomeDir } from '../hooks.js';
+import { codexHomeDir } from '../hooks/shared.js';
 import { readTextFile } from './files.js';
 import { textItemKeys } from './keys.js';
 import { splitMarkdownItems } from './markdown.js';

package/dist/agent-memories/gemini.js

@@ -2,7 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { isStringValue } from '../capture-contract.js';
-import { isJsonObject } from '../hooks.js';
+import { isJsonObject } from '../hooks/shared.js';
 import { readTextFile, splitFrontmatter } from './files.js';
 import { markdownNotes, readFolderStore } from './folder-store.js';
 import { gitLayout } from './git.js';

package/dist/agent-memories/legacy.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import { duplicateKey } from '../same-text.js';
 import { maskEmails } from '../secret-detect.js';
-import { selectLiveEntriesBySourcePrefix } from '../store.js';
+import { selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
 import { matchLegacy } from './plan.js';
 import { MIN_ITEM_CHARS, storedText } from './source.js';
 export const LEGACY_SOURCE_PREFIX = 'claude-memory:';

package/dist/agent-memories/source.js

@@ -1,6 +1,6 @@
 // An imported row's source, `agent-memory:<tool>:<container>/<item>#<hash>`, and the stored text: plan design 3 and 4.
 import { realpathOrResolve } from '../project-identity.js';
-import { truncateCodePointSafe } from '../capture.js';
+import { truncateCodePointSafe } from '../transcript-tail.js';
 import { maskEmails } from '../secret-detect.js';
 import { itemHash, sha256Hex } from './keys.js';
 import { toolSourcePrefix } from './tools.js';

package/dist/agent-memories/sync.js

@@ -1,13 +1,18 @@
 // Runs the adapters and routes each container to its store: the project pass, the user pass and their call sites (plan designs 2, 8, 11).
+import { processEnv } from '../env.js';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { errorMessage } from '../capture.js';
+import { errorMessage } from '../log.js';
 import { loadConfig } from '../config.js';
 import { closeHippoDb, isSqliteBusy, openHippoDb } from '../db.js';
 import { deriveOriginProject, isGlobalStoreRoot, resolveGlobalRootDir } from '../project-identity.js';
 import { duplicateKey, heldTextKeys } from '../same-text.js';
-import { initStore, isInitialized, removeEntryMirrors, selectLiveEntriesBySourcePrefix, updateStats, writeEntryMirrors } from '../store.js';
+import { removeEntryMirrors } from '../store/mirrors.js';
+import { initStore, isInitialized } from '../store/open.js';
+import { writeEntryMirrors } from '../store/entry-writes.js';
+import { selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
+import { updateStats } from '../store/index-and-stats.js';
 import { resolveTenantId } from '../tenant.js';
 import { setAsideRow, syncContainer } from './apply.js';
 import { claudeCodeAdapter, claudeTranscriptListing } from './claude-code.js';
@@ -24,7 +29,7 @@ export const ADAPTERS = [claudeCodeAdapter, codexAdapter, geminiAdapter, copilot
 /** Overrides config because `hippo init` creates the store in the same command that imports (plan design 11). */
 export const TOOLS_ENV = 'HIPPO_AGENT_MEMORY_TOOLS';
 export function currentMachine() {
-    return { home: os.homedir(), env: process.env, platform: process.platform };
+    return { home: os.homedir(), env: processEnv(), platform: process.platform };
 }
 /** init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the global store the user pass only. */
 export function importForStore(hippoRoot, opts) {

package/dist/ambient-store.d.ts

@@ -0,0 +1,14 @@
+import { type AmbientTallies } from './ambient.js';
+/** The rows an ambient summary describes: a context read's envelope, origin partition and tag secret veto. */
+export interface AmbientStoreFilter {
+    exactScope?: string;
+    /** Rows of this project and user-global rows pass; absent admits every origin. */
+    project?: string;
+    /** The reader's project: a secret-tagged row counts only inside its own non-empty origin project. */
+    currentProject: string;
+    now: Date;
+}
+/** Whole-store ambient tallies in one aggregate pass, no row loaded. Content-pattern secrets and session-local
+ *  rows (own compaction items, a printed handoff's digest) still count: only injection drops them. */
+export declare function loadAmbientTallies(hippoRoot: string, tenantId: string, filter: AmbientStoreFilter): AmbientTallies;
+//# sourceMappingURL=ambient-store.d.ts.map

package/dist/ambient-store.js

@@ -0,0 +1,90 @@
+import { closeHippoDb } from './db.js';
+import { strengthSql } from './memory.js';
+import { RECALL_DEFAULT_DENY_SCOPES } from './recall-scope.js';
+import { SECRET_TAGS } from './secret-detect.js';
+import { openStore } from './store/open.js';
+import { isErrorTagged } from './ambient.js';
+// A malformed or non-array JSON list reads as empty, as parseJsonArray does, instead of failing json_each.
+const jsonList = (column) => `(CASE WHEN json_valid(${column}) AND json_type(${column}) = 'array' THEN ${column} ELSE '[]' END)`;
+// SHORTCUT: mirrors loadContextCandidates' WHERE (request-path snapshots pin the match); share it once store.ts is split.
+function contextRowsWhere(tenantId, filter) {
+    const where = ['tenant_id = ?', `COALESCE(superseded_by, '') = ''`, `COALESCE(kind, '') != 'archived'`];
+    const params = [tenantId];
+    if (filter.exactScope) {
+        where.push('scope = ?');
+        params.push(filter.exactScope);
+    }
+    else {
+        where.push(`(scope IS NULL OR (scope NOT IN (${RECALL_DEFAULT_DENY_SCOPES.map(() => '?').join(', ')}) AND scope NOT LIKE '%:private:%'))`);
+        params.push(...RECALL_DEFAULT_DENY_SCOPES);
+    }
+    if (filter.project !== undefined) {
+        where.push(`(origin_project = '' OR origin_project = ?)`);
+        params.push(filter.project);
+    }
+    return { where, params };
+}
+/** A secret tag's row, the half of detectSecret SQL can check; the LIKEs only skip json_each on rows that cannot match. */
+function secretTaggedSql() {
+    const tags = [...SECRET_TAGS];
+    return {
+        sql: `((${tags.map(() => 'tags_json LIKE ?').join(' OR ')})
+      AND EXISTS (SELECT 1 FROM json_each(${jsonList('tags_json')}) WHERE lower(value) IN (${tags.map(() => '?').join(', ')})))`,
+        params: [...tags.map((t) => `%"${t}"%`), ...tags],
+    };
+}
+/** Whole-store ambient tallies in one aggregate pass, no row loaded. Content-pattern secrets and session-local
+ *  rows (own compaction items, a printed handoff's digest) still count: only injection drops them. */
+export function loadAmbientTallies(hippoRoot, tenantId, filter) {
+    const { where, params } = contextRowsWhere(tenantId, filter);
+    const secret = secretTaggedSql();
+    const sevenDaysAgo = new Date(filter.now.getTime() - 7 * 86400000).toISOString();
+    const db = openStore(hippoRoot);
+    try {
+        // SAFETY: one aggregate row whose columns are the aliases named below. Tag lists come back as one JSON array of
+        // arrays and are counted in JS, which maps items through String() as parseJsonArray does.
+        const row = db.prepare(`SELECT
+      COUNT(*) AS total,
+      COALESCE(SUM(${strengthSql(filter.now)}), 0) AS strengthSum,
+      COALESCE(SUM(julianday(created) > julianday(?)), 0) AS fresh,
+      COALESCE(SUM(emotional_valence IN ('negative', 'critical')), 0) AS negative,
+      COALESCE(SUM(COALESCE(schema_fit, 0.5) > 0.7), 0) AS highSchemaFit,
+      COALESCE(SUM(layer = 'semantic'), 0) AS semantic,
+      COALESCE(SUM(layer = 'episodic'), 0) AS episodic,
+      COALESCE(SUM(json_array_length(${jsonList('conflicts_with_json')})), 0) AS conflicts,
+      COALESCE(SUM(COALESCE(extracted_from, '') != ''), 0) AS extracted,
+      MAX(0, COALESCE(MAX(COALESCE(dag_level, 0)), 0)) AS maxDagLevel,
+      '[' || COALESCE(group_concat(${jsonList('tags_json')}, ','), '') || ']' AS tagLists
+      FROM memories
+      WHERE ${where.join(' AND ')}
+        AND ((origin_project = ? AND origin_project != '') OR NOT ${secret.sql})`).get(sevenDaysAgo, ...params, filter.currentProject, ...secret.params);
+        const tagCounts = new Map();
+        let errors = 0;
+        const lists = /* SAFETY: jsonList yields an array per row, joined into one array */ JSON.parse(row.tagLists);
+        for (const raw of lists) {
+            const tags = raw.map((item) => String(item));
+            for (const tag of tags)
+                tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+            if (isErrorTagged(tags))
+                errors++;
+        }
+        return {
+            total: Number(row.total),
+            strengthSum: Number(row.strengthSum),
+            fresh: Number(row.fresh),
+            negative: Number(row.negative),
+            highSchemaFit: Number(row.highSchemaFit),
+            errors,
+            semantic: Number(row.semantic),
+            episodic: Number(row.episodic),
+            conflicts: Number(row.conflicts),
+            extracted: Number(row.extracted),
+            maxDagLevel: Number(row.maxDagLevel),
+            tagCounts,
+        };
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+//# sourceMappingURL=ambient-store.js.map

package/dist/ambient.d.ts

@@ -20,7 +20,30 @@ export interface AmbientState {
     dagDepth: number;
     totalMemories: number;
 }
+/** Row counts and sums an AmbientState is derived from; two stores' tallies add with addAmbientTallies. */
+export interface AmbientTallies {
+    total: number;
+    strengthSum: number;
+    fresh: number;
+    negative: number;
+    highSchemaFit: number;
+    errors: number;
+    semantic: number;
+    episodic: number;
+    conflicts: number;
+    extracted: number;
+    maxDagLevel: number;
+    tagCounts: Map<string, number>;
+}
+/** The tallies of two disjoint row sets taken together. */
+export declare function addAmbientTallies(a: AmbientTallies, b: AmbientTallies): AmbientTallies;
+/** Whether a tag list marks its memory as an error for errorDensity. */
+export declare function isErrorTagged(tags: readonly string[]): boolean;
+/** Tallies over loaded entries; superseded rows count toward the total only, as they always have here. */
+export declare function tallyAmbientEntries(entries: readonly MemoryEntry[], now?: Date): AmbientTallies;
 export declare function computeAmbientState(entries: MemoryEntry[], now?: Date): AmbientState;
+/** The ambient state of a row set from its tallies, however they were counted. */
+export declare function ambientStateFromTallies(t: AmbientTallies): AmbientState;
 export declare function renderAmbientSummary(state: AmbientState): string;
 export declare function formatAmbientVector(state: AmbientState): string;
 //# sourceMappingURL=ambient.d.ts.map

package/dist/ambient.js

@@ -9,67 +9,89 @@
 import { evalNow } from './ablation.js';
 import { Layer } from './memory.js';
 import { calculateStrength } from './memory.js';
-export function computeAmbientState(entries, now) {
-    const n = entries.length;
-    if (n === 0) {
-        return {
-            tagEntropy: 0, avgStrength: 0, recencyFreshness: 0,
-            emotionalSkew: 0, schemaFitRatio: 0, errorDensity: 0,
-            consolidationRatio: 0, conflictIntensity: 0,
-            extractionCoverage: 0, dagDepth: 0, totalMemories: 0,
-        };
-    }
+/** The tallies of two disjoint row sets taken together. */
+export function addAmbientTallies(a, b) {
+    const tagCounts = new Map(a.tagCounts);
+    for (const [tag, count] of b.tagCounts)
+        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + count);
+    return {
+        total: a.total + b.total,
+        strengthSum: a.strengthSum + b.strengthSum,
+        fresh: a.fresh + b.fresh,
+        negative: a.negative + b.negative,
+        highSchemaFit: a.highSchemaFit + b.highSchemaFit,
+        errors: a.errors + b.errors,
+        semantic: a.semantic + b.semantic,
+        episodic: a.episodic + b.episodic,
+        conflicts: a.conflicts + b.conflicts,
+        extracted: a.extracted + b.extracted,
+        maxDagLevel: Math.max(a.maxDagLevel, b.maxDagLevel),
+        tagCounts,
+    };
+}
+/** Whether a tag list marks its memory as an error for errorDensity. */
+export function isErrorTagged(tags) {
+    return tags.some(tag => tag === 'error' || tag === 'critical' || tag.startsWith('error:'));
+}
+/** Tallies over loaded entries; superseded rows count toward the total only, as they always have here. */
+export function tallyAmbientEntries(entries, now) {
     const currentTime = now ?? evalNow(); // honors HIPPO_FAKE_NOW (eval-only)
-    const tagCounts = new Map();
-    let strengthSum = 0;
-    let freshCount = 0;
-    let negativeCount = 0;
-    let highSchemaCount = 0;
-    let errorCount = 0;
-    let semanticCount = 0;
-    let episodicCount = 0;
-    let conflictSum = 0;
-    let extractedCount = 0;
-    let maxDagLevel = 0;
     const sevenDaysAgo = currentTime.getTime() - 7 * 86400000;
+    const t = {
+        total: entries.length, strengthSum: 0, fresh: 0, negative: 0, highSchemaFit: 0, errors: 0,
+        semantic: 0, episodic: 0, conflicts: 0, extracted: 0, maxDagLevel: 0, tagCounts: new Map(),
+    };
     for (const entry of entries) {
         if (entry.superseded_by)
             continue;
-        for (const tag of entry.tags) {
-            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-        }
-        const strength = calculateStrength(entry, currentTime);
-        strengthSum += strength;
+        for (const tag of entry.tags)
+            t.tagCounts.set(tag, (t.tagCounts.get(tag) ?? 0) + 1);
+        t.strengthSum += calculateStrength(entry, currentTime);
         if (new Date(entry.created).getTime() > sevenDaysAgo)
-            freshCount++;
-        if (entry.emotional_valence === 'negative' || entry.emotional_valence === 'critical') {
-            negativeCount++;
-        }
-        if (entry.tags.some(t => t === 'error' || t === 'critical' || t.startsWith('error:'))) {
-            errorCount++;
-        }
+            t.fresh++;
+        if (entry.emotional_valence === 'negative' || entry.emotional_valence === 'critical')
+            t.negative++;
+        if (isErrorTagged(entry.tags))
+            t.errors++;
         if (entry.schema_fit > 0.7)
-            highSchemaCount++;
+            t.highSchemaFit++;
         if (entry.layer === Layer.Semantic)
-            semanticCount++;
+            t.semantic++;
         if (entry.layer === Layer.Episodic)
-            episodicCount++;
-        conflictSum += entry.conflicts_with.length;
+            t.episodic++;
+        t.conflicts += entry.conflicts_with.length;
         if (entry.extracted_from)
-            extractedCount++;
-        if (entry.dag_level > maxDagLevel)
-            maxDagLevel = entry.dag_level;
+            t.extracted++;
+        if (entry.dag_level > t.maxDagLevel)
+            t.maxDagLevel = entry.dag_level;
+    }
+    return t;
+}
+export function computeAmbientState(entries, now) {
+    return ambientStateFromTallies(tallyAmbientEntries(entries, now));
+}
+/** The ambient state of a row set from its tallies, however they were counted. */
+export function ambientStateFromTallies(t) {
+    const n = t.total;
+    if (n === 0) {
+        return {
+            tagEntropy: 0, avgStrength: 0, recencyFreshness: 0,
+            emotionalSkew: 0, schemaFitRatio: 0, errorDensity: 0,
+            consolidationRatio: 0, conflictIntensity: 0,
+            extractionCoverage: 0, dagDepth: 0, totalMemories: 0,
+        };
     }
-    const tagEntropy = shannonEntropy(tagCounts, n);
-    const avgStrength = strengthSum / n;
-    const recencyFreshness = freshCount / n;
-    const emotionalSkew = (negativeCount / n) * 2 - 0.5;
-    const schemaFitRatio = highSchemaCount / n;
-    const errorDensity = errorCount / n;
-    const totalLayered = semanticCount + episodicCount;
-    const consolidationRatio = totalLayered > 0 ? semanticCount / totalLayered : 0;
-    const conflictIntensity = conflictSum / (n * 2);
-    const extractionCoverage = episodicCount > 0 ? extractedCount / episodicCount : 0;
+    const tagEntropy = shannonEntropy(t.tagCounts, n);
+    const avgStrength = t.strengthSum / n;
+    const recencyFreshness = t.fresh / n;
+    const emotionalSkew = (t.negative / n) * 2 - 0.5;
+    const schemaFitRatio = t.highSchemaFit / n;
+    const errorDensity = t.errors / n;
+    const totalLayered = t.semantic + t.episodic;
+    const consolidationRatio = totalLayered > 0 ? t.semantic / totalLayered : 0;
+    const conflictIntensity = t.conflicts / (n * 2);
+    const extractionCoverage = t.episodic > 0 ? t.extracted / t.episodic : 0;
+    const maxDagLevel = t.maxDagLevel;
     return {
         tagEntropy,
         avgStrength,

package/dist/api/assemble.d.ts

@@ -0,0 +1,93 @@
+import type { Context } from './types.js';
+export interface AssembleOpts {
+    /** Token budget. Default 4000. */
+    budget?: number;
+    /** Recent raw rows always kept verbatim. Default 10. */
+    freshTailCount?: number;
+    /** Substitute parent summaries for older raws when ≥2 share a level-2
+     *  ancestor. Default true. */
+    summarizeOlder?: boolean;
+    /**
+     * Restrict to a specific scope. v1.6.1 senior-review P1 #3 parity with
+     * `recall`: when set, exact match required (so an authorised caller can
+     * assemble a `slack:private:CSEC` session by passing scope explicitly).
+     * When undefined, default-deny applies to ANY `<source>:private:*` and
+     * `unknown:legacy` rows.
+     */
+    scope?: string;
+    /**
+     * Hard row cap on the SELECT that loads session raws. Default 5000 to
+     * protect against degenerate sessions. When the cap is hit, `truncated`
+     * is set on the result so the caller knows to widen.
+     */
+    rowCap?: number;
+    cost?: AssembleCost;
+}
+export interface AssembleCost {
+    item: (it: AssembledContextItem) => number;
+    fixed: (widest: number) => number;
+}
+export interface AssembledContextItem {
+    id: string;
+    content: string;
+    /** ISO timestamp of the source row's `created` field (or `earliest_at`
+     *  for substituted summaries). */
+    createdAt: string;
+    /** Fresh-tail protected window (last freshTailCount raws). */
+    isFreshTail?: boolean;
+    /** Level-2 summary substituted for older raw rows that share a parent. */
+    isSummary?: boolean;
+    /** When isSummary, the raw ids this summary covers. drillDown
+     *  recovers the originals. */
+    substitutedFor?: string[];
+    /** Decay × retrieval × emotional. Lets callers render a confidence
+     *  hint without re-deriving from MemoryEntry. */
+    strength: number;
+}
+export interface AssembleResult {
+    sessionId: string;
+    items: AssembledContextItem[];
+    tokens: number;
+    /**
+     * Tenant + scope-filtered raw row count for the session — what the caller
+     * could have seen given their grant. Pre-v1.6.1 was pre-filter (confusing
+     * for all-private sessions); pre-v1.6.3 was capped (under-reported on
+     * sessions > rowCap). v1.6.3 reports the FULL post-filter count via a
+     * separate COUNT(*) query so consumers can render "session has N msgs"
+     * accurately even when items[] is the windowed view.
+     */
+    totalRaw: number;
+    summarized: number;
+    evicted: number;
+    /**
+     * True when `rowCap` truncated the loaded window. With v1.6.2's NEWEST-cap
+     * semantics, the items[] array represents the freshest tail of the session;
+     * older rows beyond the cap are silently absent. Use `totalRaw - items.length
+     * - summarized + ...` to estimate how much you didn't see, or widen `rowCap`.
+     */
+    truncated: boolean;
+}
+/**
+ * Build a chronologically-ordered context window for a session. Adapts the
+ * lossless-claw context-engine pattern to Hippo's score-ranked memory store.
+ *
+ * Algorithm:
+ *   1. Load all kind='raw' rows for the session, tenant + scope filtered.
+ *   2. Split: newest `freshTailCount` are protected (fresh tail).
+ *   3. For older rows, when ≥2 share a level-2 parent, substitute the
+ *      summary; everything else passes through as raw.
+ *   4. Hippo-additive eviction: when over-budget, drop the lowest-strength
+ *      non-fresh-tail item first. Fresh-tail rows are never evicted.
+ *
+ * Strength-weighted eviction is the differentiator from lossless-claw,
+ * which evicts oldest-first. A high-strength older row (high retrieval
+ * count, slow decay) survives; a low-strength recent row (newer but
+ * unimportant) goes first.
+ *
+ * Returns `items: []` cleanly when:
+ *   - sessionId is empty
+ *   - no raws exist for the session
+ *   - all rows fail the scope/tenant filter
+ */
+export declare function assemble(ctx: Context, sessionId: string, opts?: AssembleOpts): AssembleResult;
+//# sourceMappingURL=assemble.d.ts.map