hippo-memory 1.72.0 → 2.1.0

package/dist/api/index.d.ts

@@ -4,27 +4,43 @@ export { passesCliRecallScopeFilter, ScopeForbiddenError } from '../core/recall-
 export type { TokenSummary, TokenSurface, TokenSurfaceSummary } from '../store/token-ledger.js';
 export type { FailureSummary } from '../store/failure-log.js';
 export { classifyOriginProject } from '../core/project-identity.js';
-export * from './types.js';
-export * from './remember.js';
-export * from './remember-local.js';
-export * from './recall-types.js';
-export * from './recall.js';
-export * from './assemble.js';
-export * from './drill-down.js';
-export * from './outcome.js';
-export * from './forget.js';
-export * from './conflicts.js';
-export * from './projects.js';
-export * from './promote.js';
-export * from './auth.js';
-export * from './audit.js';
-export * from './context-types.js';
-export * from './context.js';
-export * from './tokens.js';
-export * from './dormant.js';
-export * from './quarantine.js';
-export * from './sleep.js';
-export * from './goals.js';
-export * from './learn.js';
-export * from './refine.js';
+export { RecallContractError, adminActor, narrowContext, ownerOrSubject, requireHostAdmin } from './types.js';
+export type { Actor, Context, ContextWith, HippoDbContext, StoreContext } from './types.js';
+export { remember } from './memories/remember.js';
+export type { RememberLocal, RememberOpts, RememberResult } from './memories/remember.js';
+export { extractRememberedFacts, rememberLocally } from './memories/remember-local.js';
+export type { FactExtraction, FactExtractionRequest, LocalRememberInput, LocalRememberOutcome, StartedWeak, } from './memories/remember-local.js';
+export type { CliCoreInspection, CliCoreRanker, CliCoreRecall, ContinuityBlock, RecallOpts, RecallResult, RecallResultItem, RecallSuppressionSummary, ShownCliCore, ShownRanking, StoreRanking, } from './recall/types.js';
+export { retrieve } from './recall/recall.js';
+export { DEFAULT_ASSEMBLE_BUDGET, assemble } from './assemble.js';
+export type { AssembleCost, AssembleOpts, AssembleResult, AssembledContextItem } from './assemble.js';
+export { drillDown } from './objects/drill-down.js';
+export type { DrillDownChild, DrillDownCost, DrillDownFailure, DrillDownOpts, DrillDownOutcome, DrillDownResult, DrillDownSummary, } from './objects/drill-down.js';
+export { outcome, outcomeForLastRecall } from './memories/outcome.js';
+export type { OutcomeForLastRecallResult, OutcomeResult } from './memories/outcome.js';
+export { forget, reject, rejectOnHost, unreject } from './memories/forget.js';
+export type { ForgetResult, RejectOpts, RejectResult } from './memories/forget.js';
+export { listConflicts, listOpenConflicts, resolveMemoryConflict } from './memories/conflicts.js';
+export type { ResolveMemoryConflictOpts, ResolveMemoryConflictResult } from './memories/conflicts.js';
+export { listProjectNames, mergeProjectNames, repairProjectNames, repairProjectNamesOnce } from './objects/projects.js';
+export type { MergeProjectNamesOpts, MergeResult, ProjectCollision, ProjectFold, ProjectSummary, RepairResult, } from './objects/projects.js';
+export { archiveRaw, promote, supersede } from './memories/promote.js';
+export type { ArchiveRawOpts, ArchiveRawResult, PromoteResult, SupersedeOverrides, SupersedeResult, } from './memories/promote.js';
+export { DEFAULT_KEY_TTL_DAYS, MAX_TTL_DAYS, authCreate, authCreateSelf, authGrant, authKeyTenant, authListAllTenants, authListRows, authRevoke, authUngrant, } from './auth/auth.js';
+export type { AuthCreateOpts, AuthCreateResult, AuthCreateSelfOpts, AuthCreateSelfResult, AuthGrantResult, AuthRevokeResult, } from './auth/auth.js';
+export { auditList, auditMemoryQuality, computeCutoff, pruneAuditLog, removeAuditErrors, repairMemoryQuality, repairMemoryQualityOnce, } from './auth/audit.js';
+export type { AuditListOpts, AuditPass, PruneAuditOpts, PruneAuditResult } from './auth/audit.js';
+export type { ContextCost, ContextOpts, ContextResult, ContextResultEntry } from './context-types.js';
+export { DEFAULT_CONTEXT_BUDGET, NO_QUERY, ambientSecretAdmit, getContext, oneCopyPerMemory } from './context.js';
+export { failureSummary, recordTokens, tokenSummary } from './tokens.js';
+export { forgetDormant, isDormant, listDormant, restoreDormant } from './sleep/dormant.js';
+export { quarantineApprove, quarantineList, quarantineReject } from './auth/quarantine.js';
+export type { QuarantineListItem } from './auth/quarantine.js';
+export { sleep } from './sleep/sleep.js';
+export type { SleepOpts, SleepResult } from './sleep/sleep.js';
+export { goalComplete, goalList, goalPush, goalResume, goalSuspend } from './objects/goals.js';
+export type { GoalPushOpts } from './objects/goals.js';
+export { CLI_LEARN, MCP_LEARN, invalidateMemories, learn } from './sleep/learn.js';
+export type { InvalidationOptions, InvalidationResult, InvalidationTarget, LearnOpts, LearnProfile, LearnResult, } from './sleep/learn.js';
+export { REFINED_TAG, storeRefinement } from './memories/refine.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.js

@@ -7,27 +7,25 @@ export { isPrivateScope, passesScopeFilterForRecall } from '../core/recall-scope
 export { passesCliRecallScopeFilter, ScopeForbiddenError } from '../core/recall-scope.js';
 // classifyOriginProject lives in project-identity.ts (leaf) for the same reason.
 export { classifyOriginProject } from '../core/project-identity.js';
-export * from './types.js';
-export * from './remember.js';
-export * from './remember-local.js';
-export * from './recall-types.js';
-export * from './recall.js';
-export * from './assemble.js';
-export * from './drill-down.js';
-export * from './outcome.js';
-export * from './forget.js';
-export * from './conflicts.js';
-export * from './projects.js';
-export * from './promote.js';
-export * from './auth.js';
-export * from './audit.js';
-export * from './context-types.js';
-export * from './context.js';
-export * from './tokens.js';
-export * from './dormant.js';
-export * from './quarantine.js';
-export * from './sleep.js';
-export * from './goals.js';
-export * from './learn.js';
-export * from './refine.js';
+export { RecallContractError, adminActor, narrowContext, ownerOrSubject, requireHostAdmin } from './types.js';
+export { remember } from './memories/remember.js';
+export { extractRememberedFacts, rememberLocally } from './memories/remember-local.js';
+export { retrieve } from './recall/recall.js';
+export { DEFAULT_ASSEMBLE_BUDGET, assemble } from './assemble.js';
+export { drillDown } from './objects/drill-down.js';
+export { outcome, outcomeForLastRecall } from './memories/outcome.js';
+export { forget, reject, rejectOnHost, unreject } from './memories/forget.js';
+export { listConflicts, listOpenConflicts, resolveMemoryConflict } from './memories/conflicts.js';
+export { listProjectNames, mergeProjectNames, repairProjectNames, repairProjectNamesOnce } from './objects/projects.js';
+export { archiveRaw, promote, supersede } from './memories/promote.js';
+export { DEFAULT_KEY_TTL_DAYS, MAX_TTL_DAYS, authCreate, authCreateSelf, authGrant, authKeyTenant, authListAllTenants, authListRows, authRevoke, authUngrant, } from './auth/auth.js';
+export { auditList, auditMemoryQuality, computeCutoff, pruneAuditLog, removeAuditErrors, repairMemoryQuality, repairMemoryQualityOnce, } from './auth/audit.js';
+export { DEFAULT_CONTEXT_BUDGET, NO_QUERY, ambientSecretAdmit, getContext, oneCopyPerMemory } from './context.js';
+export { failureSummary, recordTokens, tokenSummary } from './tokens.js';
+export { forgetDormant, isDormant, listDormant, restoreDormant } from './sleep/dormant.js';
+export { quarantineApprove, quarantineList, quarantineReject } from './auth/quarantine.js';
+export { sleep } from './sleep/sleep.js';
+export { goalComplete, goalList, goalPush, goalResume, goalSuspend } from './objects/goals.js';
+export { CLI_LEARN, MCP_LEARN, invalidateMemories, learn } from './sleep/learn.js';
+export { REFINED_TAG, storeRefinement } from './memories/refine.js';
 //# sourceMappingURL=index.js.map

package/dist/api/instruction-detect.d.ts

@@ -1,4 +1,7 @@
-/** Prompt-injection detection for untrusted memory content. Same shape as secret-detect.ts; leaf module, no store/api/shared imports. */
+/**
+ * Prompt-injection detection for untrusted memory content. Same shape
+ * as secret-detect.ts; leaf module, no store/api/shared imports.
+ */
 export interface InstructionDetection {
     flagged: boolean;
     reason: string | null;

package/dist/api/instruction-detect.js

@@ -1,7 +1,16 @@
-/** Prompt-injection detection for untrusted memory content. Same shape as secret-detect.ts; leaf module, no store/api/shared imports. */
+/**
+ * Prompt-injection detection for untrusted memory content. Same shape
+ * as secret-detect.ts; leaf module, no store/api/shared imports.
+ */
 const INSTRUCTION_PATTERNS = [
-    { name: 'override-instructions', re: /\b(?:ignore|disregard|forget)\b[^.\n]{0,40}\b(?:previous|prior|above)\b[^.\n]{0,40}\binstructions?\b/i },
-    { name: 'role-reassignment', re: /\b(?:you are now|act as|pretend to be)\b[^.\n]{0,40}\b(?:an?\s+)?(?:ai|assistant|agent|system)\b/i },
+    {
+        name: 'override-instructions',
+        re: /\b(?:ignore|disregard|forget)\b[^.\n]{0,40}\b(?:previous|prior|above)\b[^.\n]{0,40}\binstructions?\b/i,
+    },
+    {
+        name: 'role-reassignment',
+        re: /\b(?:you are now|act as|pretend to be)\b[^.\n]{0,40}\b(?:an?\s+)?(?:ai|assistant|agent|system)\b/i,
+    },
     { name: 'chat-role-markup', re: /<\|im_start\|>|<\|system\|>|\[INST\]|<\/?system>|###\s*system\s*:/i },
     {
         name: 'system-prompt-reference',
@@ -11,16 +20,22 @@ const INSTRUCTION_PATTERNS = [
     // "always"/"never" alone (ordinary PR prose) doesn't flag without an agent-facing target nearby too.
     {
         name: 'standing-order',
-        re: /\b(?:from now on|whenever you|always|never)\b[^.\n]{0,50}\b(?:you must|(?:the ai|the assistant|the agent|claude|copilot)\s+(?:must|should|will)\b)/i
+        re: new RegExp(String.raw `\b(?:from now on|whenever you|always|never)\b[^.\n]{0,50}\b(?:you must|` +
+            String.raw `(?:the ai|the assistant|the agent|claude|copilot)\s+(?:must|should|will)\b)`, 'i'),
+    },
+    {
+        name: 'concealment',
+        re: /\b(?:do not|never|don't)\b[^.\n]{0,40}\b(?:tell|mention|reveal)\b[^.\n]{0,40}\bthe user\b/i,
     },
-    { name: 'concealment', re: /\b(?:do not|never|don't)\b[^.\n]{0,40}\b(?:tell|mention|reveal)\b[^.\n]{0,40}\bthe user\b/i },
     {
         name: 'remote-script-exec',
-        re: /\b(?:curl|wget)\b[^\n|]{0,80}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b|\biex\s*\(\s*(?:iwr|invoke-webrequest|new-object\s+net\.webclient)/i
+        re: new RegExp(String.raw `\b(?:curl|wget)\b[^\n|]{0,80}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)\b|` +
+            String.raw `\biex\s*\(\s*(?:iwr|invoke-webrequest|new-object\s+net\.webclient)`, 'i'),
     },
     {
         name: 'exfiltration',
-        re: /\b(?:send|post|upload|exfiltrate)\b[^.\n]{0,40}\b(?:secrets?|tokens?|api[- ]?keys?|credentials?|env(?:ironment)? variables?)\b/i
+        re: new RegExp(String.raw `\b(?:send|post|upload|exfiltrate)\b[^.\n]{0,40}\b` +
+            String.raw `(?:secrets?|tokens?|api[- ]?keys?|credentials?|env(?:ironment)? variables?)\b`, 'i'),
     },
     { name: 'unicode-tag-chars', re: /[\u{E0000}-\u{E007F}]/u },
 ];
@@ -30,20 +45,59 @@ const ZERO_WIDTH_RUN_RE = /[\u200B-\u200F\u2060-\u2064]{3,}/;
 const BIDI_CONTROL_RE = /[\u202A-\u202E\u2066-\u2069]/;
 // A renderer draws a reference as the character it names: decimal, hex, or one of the five names XML defines.
 const CHARACTER_REFERENCE_RE = /&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|(amp|lt|gt|quot|apos));/g;
-const NAMED_REFERENCES = new Map([['amp', '&'], ['lt', '<'], ['gt', '>'], ['quot', '"'], ['apos', "'"]]);
-// Drawn with no width, so one inside a word splits it for a pattern and not for a reader: soft hyphen, joiners, zero-width and bidi format characters.
+const NAMED_REFERENCES = new Map([
+    ['amp', '&'],
+    ['lt', '<'],
+    ['gt', '>'],
+    ['quot', '"'],
+    ['apos', "'"],
+]);
+// Drawn with no width, so one inside a word splits it for a pattern and not for a reader: soft hyphen, joiners,
+// zero-width and bidi format characters.
 const INVISIBLE_RE = /[\u034F\u00AD\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/g;
-// Cyrillic, then Greek, letters drawn like a c e i j o p s x y; closed at those, so Russian or Greek prose folds into no phrase a pattern names.
+// Cyrillic, then Greek, letters drawn like a c e i j o p s x y; closed at those, so Russian or Greek prose folds into
+// no phrase a pattern names.
 const LOOKALIKES = new Map([
-    ['\u0430', 'a'], ['\u0441', 'c'], ['\u0435', 'e'], ['\u0456', 'i'], ['\u0458', 'j'], ['\u043E', 'o'], ['\u0440', 'p'], ['\u0455', 's'],
-    ['\u0445', 'x'], ['\u0443', 'y'],
-    ['\u0410', 'A'], ['\u0421', 'C'], ['\u0415', 'E'], ['\u0406', 'I'], ['\u0408', 'J'], ['\u041E', 'O'], ['\u0420', 'P'], ['\u0405', 'S'],
-    ['\u0425', 'X'], ['\u0423', 'Y'],
-    ['\u03B1', 'a'], ['\u03B5', 'e'], ['\u03B9', 'i'], ['\u03F3', 'j'], ['\u03BF', 'o'], ['\u03C1', 'p'], ['\u03C7', 'x'], ['\u03B3', 'y'],
-    ['\u0391', 'A'], ['\u0395', 'E'], ['\u0399', 'I'], ['\u037F', 'J'], ['\u039F', 'O'], ['\u03A1', 'P'], ['\u03A7', 'X'], ['\u03A5', 'Y'],
+    ['\u0430', 'a'],
+    ['\u0441', 'c'],
+    ['\u0435', 'e'],
+    ['\u0456', 'i'],
+    ['\u0458', 'j'],
+    ['\u043E', 'o'],
+    ['\u0440', 'p'],
+    ['\u0455', 's'],
+    ['\u0445', 'x'],
+    ['\u0443', 'y'],
+    ['\u0410', 'A'],
+    ['\u0421', 'C'],
+    ['\u0415', 'E'],
+    ['\u0406', 'I'],
+    ['\u0408', 'J'],
+    ['\u041E', 'O'],
+    ['\u0420', 'P'],
+    ['\u0405', 'S'],
+    ['\u0425', 'X'],
+    ['\u0423', 'Y'],
+    ['\u03B1', 'a'],
+    ['\u03B5', 'e'],
+    ['\u03B9', 'i'],
+    ['\u03F3', 'j'],
+    ['\u03BF', 'o'],
+    ['\u03C1', 'p'],
+    ['\u03C7', 'x'],
+    ['\u03B3', 'y'],
+    ['\u0391', 'A'],
+    ['\u0395', 'E'],
+    ['\u0399', 'I'],
+    ['\u037F', 'J'],
+    ['\u039F', 'O'],
+    ['\u03A1', 'P'],
+    ['\u03A7', 'X'],
+    ['\u03A5', 'Y'],
 ]);
 const GREEK_OR_CYRILLIC_RE = /[\u0370-\u03FF\u0400-\u04FF]/g;
-// A line break stays: it is the sentence bound the patterns rely on where a list or a chat message ends a line with no full stop.
+// A line break stays: it is the sentence bound the patterns rely
+// on where a list or a chat message ends a line with no full stop.
 const SPACE_RUN_RE = /[^\S\n]+/g;
 function referencedCharacter(reference, decimal, hex, name) {
     if (name !== undefined)
@@ -55,13 +109,13 @@ function referencedCharacter(reference, decimal, hex, name) {
 }
 /** `content` as a reader or a model takes it in. For matching only: what is stored is never this. */
 function screeningForm(content) {
-    return content
+    return (content
         .replace(CHARACTER_REFERENCE_RE, referencedCharacter)
         // Full-width, mathematical and enclosed letters become the plain ones, and every space character a U+0020.
         .normalize('NFKC')
         .replace(INVISIBLE_RE, '')
         .replace(GREEK_OR_CYRILLIC_RE, (letter) => LOOKALIKES.get(letter) ?? letter)
-        .replace(SPACE_RUN_RE, ' ');
+        .replace(SPACE_RUN_RE, ' '));
 }
 function matchedPattern(text) {
     for (const { name, re } of INSTRUCTION_PATTERNS) {
@@ -71,7 +125,8 @@ function matchedPattern(text) {
     return null;
 }
 export function detectInstruction(content) {
-    // The text as written goes first: a phrase in plain sight is named before any smuggling rule, and the screening form only adds flags.
+    // The text as written goes first: a phrase in plain sight is named before any smuggling rule, and the screening form
+    // only adds flags.
     const plain = matchedPattern(content);
     if (plain !== null)
         return { flagged: true, reason: plain };

package/dist/api/ledger-db.d.ts

@@ -1,17 +1,21 @@
 import { type LedgerTurn } from '../store/ledger-turn.js';
+import { type HippoStore, type StoreReach } from '../store/port.js';
 import type { LastSent, TokenSurface, TokenUse } from '../store/token-ledger.js';
-export interface LedgerRootOpts {
-    /** The store serves many people, so the global store of the user running it belongs to none of them. */
-    readonly sharedStore?: boolean;
-}
-/** `hippoRoot` when it holds a store, else the global store (the prompt hook fires where no local one exists), else null. */
-export declare function ledgerRoot(hippoRoot: string, opts?: LedgerRootOpts): string | null;
-/** Runs `call` on ledgerRoot's store root. Best-effort: undefined on any failure, because a ledger failure must not break context or recall. */
-export declare function onLedgerRoot<T>(hippoRoot: string, opts: LedgerRootOpts | undefined, call: (root: string) => T): T | undefined;
+/** The slice of a call's store reach that picks the ledger; a shared store has no `global`. */
+export type LedgerReach = Pick<StoreReach, 'hasLocal' | 'global'>;
+/** The ledger is SQLite-only: a local store needs a reach that says so and a SQLite store; no reach books nowhere. */
+export declare function ledgerReachOf(ctx: {
+    readonly reach?: StoreReach;
+    readonly store?: HippoStore;
+}, shared?: boolean): LedgerReach;
+/** `hippoRoot` when the call has a store of its own, else the global store (the prompt hook fires where none is). */
+export declare function ledgerRoot(hippoRoot: string, reach: LedgerReach): string | null;
+/** Runs `call` on ledgerRoot's store root; undefined on any failure, since a ledger failure must not break recall. */
+export declare function onLedgerRoot<T>(hippoRoot: string, reach: LedgerReach, call: (root: string) => T): T | undefined;
 /** Books one row in ledgerRoot's store, best-effort. */
-export declare function bookTokenUse(hippoRoot: string, use: TokenUse, opts?: LedgerRootOpts): void;
+export declare function bookTokenUse(hippoRoot: string, use: TokenUse, reach: LedgerReach): void;
 /** Books a turn's rows and then its delivery event on one connection of ledgerRoot's store, best-effort. */
-export declare function bookLedgerTurn(hippoRoot: string, turn: LedgerTurn, opts?: LedgerRootOpts): void;
+export declare function bookLedgerTurn(hippoRoot: string, turn: LedgerTurn, reach: LedgerReach): void;
 /** What the session last sent on `surface` in ledgerRoot's store; undefined with no ledger or a failed read. */
-export declare function ledgerLastSent(hippoRoot: string, tenantId: string, sessionId: string | null | undefined, surface: TokenSurface, opts?: LedgerRootOpts): LastSent | null | undefined;
+export declare function ledgerLastSent(hippoRoot: string, tenantId: string, sessionId: string | null | undefined, surface: TokenSurface, reach: LedgerReach): LastSent | null | undefined;
 //# sourceMappingURL=ledger-db.d.ts.map

package/dist/api/ledger-db.js

@@ -1,27 +1,25 @@
 // The store the token ledger writes to for a caller's root; context, recall and the session hooks share it.
-import { errorMessage, log } from '../util/log.js';
-import { getGlobalRoot } from '../sharing/global-store.js';
-import { lastSentOnSurface, noteLedgerRowSkipped, recordLedgerTurn } from '../store/ledger-turn.js';
-import { isInitialized } from '../core/project-identity.js';
-import { sqliteSyncStore } from '../store/sqlite/store.js';
-/** `hippoRoot` when it holds a store, else the global store (the prompt hook fires where no local one exists), else null. */
-export function ledgerRoot(hippoRoot, opts) {
-    if (isInitialized(hippoRoot))
-        return hippoRoot;
-    if (opts?.sharedStore)
-        return null;
-    const globalRoot = getGlobalRoot();
-    return isInitialized(globalRoot) ? globalRoot : null;
+import { errorMessage, log, errorFields } from '../util/log.js';
+import { lastSentOnSurface, noteLedgerRowSkipped, recordLedgerTurn, recordTokensAt, } from '../store/ledger-turn.js';
+import { hasGroup } from '../store/port.js';
+/** The ledger is SQLite-only: a local store needs a reach that says so and a SQLite store; no reach books nowhere. */
+export function ledgerReachOf(ctx, shared) {
+    const hasLocal = ctx.reach?.hasLocal === true && (ctx.store === undefined || hasGroup(ctx.store, 'localFiles'));
+    return shared === true ? { hasLocal } : { hasLocal, global: ctx.reach?.global };
 }
-/** Runs `call` on ledgerRoot's store root. Best-effort: undefined on any failure, because a ledger failure must not break context or recall. */
-export function onLedgerRoot(hippoRoot, opts, call) {
+/** `hippoRoot` when the call has a store of its own, else the global store (the prompt hook fires where none is). */
+export function ledgerRoot(hippoRoot, reach) {
+    return reach.hasLocal ? hippoRoot : (reach.global?.root ?? null);
+}
+/** Runs `call` on ledgerRoot's store root; undefined on any failure, since a ledger failure must not break recall. */
+export function onLedgerRoot(hippoRoot, reach, call) {
     let root = null;
     try {
-        root = ledgerRoot(hippoRoot, opts);
+        root = ledgerRoot(hippoRoot, reach);
     }
     catch (error) {
         // An unreadable store root means no ledger write; the ledger must never break context or recall.
-        log.debug(`token ledger skipped, store root unreadable: ${errorMessage(error)}`);
+        log.debug(`token ledger skipped, store root unreadable: ${errorMessage(error)}`, errorFields(error));
         return undefined;
     }
     if (root === null)
@@ -35,15 +33,15 @@ export function onLedgerRoot(hippoRoot, opts, call) {
     }
 }
 /** Books one row in ledgerRoot's store, best-effort. */
-export function bookTokenUse(hippoRoot, use, opts) {
-    onLedgerRoot(hippoRoot, opts, (root) => sqliteSyncStore(root).recordTokens(use));
+export function bookTokenUse(hippoRoot, use, reach) {
+    onLedgerRoot(hippoRoot, reach, (root) => recordTokensAt(root, use));
 }
 /** Books a turn's rows and then its delivery event on one connection of ledgerRoot's store, best-effort. */
-export function bookLedgerTurn(hippoRoot, turn, opts) {
-    onLedgerRoot(hippoRoot, opts, (root) => recordLedgerTurn(root, turn));
+export function bookLedgerTurn(hippoRoot, turn, reach) {
+    onLedgerRoot(hippoRoot, reach, (root) => recordLedgerTurn(root, turn));
 }
 /** What the session last sent on `surface` in ledgerRoot's store; undefined with no ledger or a failed read. */
-export function ledgerLastSent(hippoRoot, tenantId, sessionId, surface, opts) {
-    return onLedgerRoot(hippoRoot, opts, (root) => lastSentOnSurface(root, tenantId, sessionId, surface));
+export function ledgerLastSent(hippoRoot, tenantId, sessionId, surface, reach) {
+    return onLedgerRoot(hippoRoot, reach, (root) => lastSentOnSurface(root, tenantId, sessionId, surface));
 }
 //# sourceMappingURL=ledger-db.js.map

package/dist/api/memories/conflicts.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryConflict } from '../../store/rows.js';
+import type { CallerProject } from '../prompt-hook.js';
+import { type ContextWith } from '../types.js';
+import type { TenantReach } from './memories.js';
+export interface ResolveMemoryConflictOpts {
+    /** One of the conflict's two memories; the other is the loser. */
+    keepId: string;
+    /** Delete the loser instead of halving its half-life. */
+    forget?: boolean;
+    /** Tombstone the loser's value as well, which removes it whatever `forget` says. */
+    rejectLoser?: boolean;
+    /** Kept on the tombstone; a conflict-context reason when unset. */
+    reason?: string;
+}
+export interface ResolveMemoryConflictResult {
+    conflictId: number;
+    keptId: string;
+    loserId: string;
+}
+/**
+ * Keeps `keepId` and weakens, deletes or rejects the other side of an open conflict in the caller's tenant, auditing as
+ * `ctx.actor`.
+ * NotFound: missing, untouchable or no longer live. Conflict: already resolved. BadRequest: `keepId` outside the pair.
+ */
+export declare function resolveMemoryConflict(ctx: ContextWith<'conflicts'>, conflictId: number, opts: ResolveMemoryConflictOpts): Promise<ResolveMemoryConflictResult>;
+/** Open conflicts whose two rows the caller may touch; with `project`, only pairs it could also recall:
+ *  its repo or user-global, and no scope it was not asked for. */
+export declare function listOpenConflicts(ctx: ContextWith<'conflicts'>, project?: CallerProject): Promise<MemoryConflict[]>;
+/**
+ * Conflicts with `status` ('*' for any) in reach, with no scope filter: the host's own view, so the host admin only.
+ */
+export declare function listConflicts(ctx: ContextWith<'conflicts'>, status: string, reach?: TenantReach): Promise<MemoryConflict[]>;
+//# sourceMappingURL=conflicts.d.ts.map

package/dist/api/memories/conflicts.js

@@ -0,0 +1,67 @@
+// Conflict resolution for every front end, so the reach, status, pair and liveness checks live in one place.
+import { BadRequestError, ConflictError, NotFoundError } from '../../core/api-errors.js';
+import { chunked } from '../../util/chunked.js';
+import { passesScopeFilterForRecall, personalScopeOf } from '../../core/recall-scope.js';
+import { classifyOriginProject } from '../../core/project-identity.js';
+import { isQuarantineScope } from '../../trust/quarantine.js';
+import { requireHostAdmin } from '../types.js';
+function isLive(entry) {
+    return (!entry.superseded_by && (entry.kind === 'raw' || entry.kind === 'distilled') && !isQuarantineScope(entry.scope));
+}
+/**
+ * Keeps `keepId` and weakens, deletes or rejects the other side of an open conflict in the caller's tenant, auditing as
+ * `ctx.actor`.
+ * NotFound: missing, untouchable or no longer live. Conflict: already resolved. BadRequest: `keepId` outside the pair.
+ */
+export async function resolveMemoryConflict(ctx, conflictId, opts) {
+    // Read with every status, so a resolved conflict answers 409 while one holding another person's personal row stays a
+    // 404.
+    const touchable = await ctx.store.conflicts.listTouchable(ctx.tenantId, '*', ctx.actor);
+    const conflict = touchable.find((c) => c.id === conflictId);
+    if (!conflict)
+        throw new NotFoundError(`conflict not found: ${conflictId}`);
+    if (conflict.status !== 'open')
+        throw new ConflictError(`conflict ${conflictId} is already resolved`);
+    const pair = [conflict.memory_a_id, conflict.memory_b_id];
+    if (!pair.includes(opts.keepId)) {
+        throw new BadRequestError(`keep must be one of the two memories in conflict ${conflictId}: ${pair.join(', ')}`);
+    }
+    if ((await ctx.store.entriesByIds(pair, ctx.tenantId)).filter(isLive).length < pair.length) {
+        throw new NotFoundError(`conflict ${conflictId} names a memory that is superseded, archived or quarantined`);
+    }
+    const resolved = await ctx.store.conflicts.resolve(ctx.tenantId, { conflictId, keepId: opts.keepId, forgetLoser: opts.forget === true }, {
+        rejectLoserValue: opts.rejectLoser === true,
+        reason: opts.reason,
+        rejectedBy: ctx.actor.subject,
+    });
+    // Every check passed above, so null here is another resolver getting there first.
+    if (resolved === null)
+        throw new ConflictError(`conflict ${conflictId} is already resolved`);
+    return { conflictId, keptId: opts.keepId, loserId: resolved.loserId };
+}
+/** Open conflicts whose two rows the caller may touch; with `project`, only pairs it could also recall:
+ *  its repo or user-global, and no scope it was not asked for. */
+export async function listOpenConflicts(ctx, project) {
+    const touchable = await ctx.store.conflicts.listTouchable(ctx.tenantId, 'open', ctx.actor);
+    if (!project)
+        return touchable;
+    const own = personalScopeOf(ctx.actor);
+    const ids = [...new Set(touchable.flatMap((c) => [c.memory_a_id, c.memory_b_id]))];
+    // entriesByIds reads at most one chunk of ids per call.
+    const chunks = await Promise.all(chunked(ids).map((chunk) => ctx.store.entriesByIds(chunk, ctx.tenantId)));
+    const rows = new Map(chunks.flat().map((row) => [row.id, row]));
+    const shown = (id) => {
+        const row = rows.get(id);
+        return row !== undefined && classifyOriginProject(row.origin_project, project) !== 'cross-project'
+            && passesScopeFilterForRecall(row.scope ?? null, undefined, own);
+    };
+    return touchable.filter((c) => shown(c.memory_a_id) && shown(c.memory_b_id));
+}
+/**
+ * Conflicts with `status` ('*' for any) in reach, with no scope filter: the host's own view, so the host admin only.
+ */
+export async function listConflicts(ctx, status, reach = {}) {
+    requireHostAdmin(ctx, 'Listing conflicts past the scope check');
+    return ctx.store.conflicts.list(reach.everyTenant ? null : ctx.tenantId, status);
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/api/{forget.d.ts → memories/forget.d.ts}

@@ -1,12 +1,12 @@
-import { type RejectFlowResult } from '../trust/reject-flow.js';
-import { type Context, type StoreReply } from './types.js';
+import { type RejectFlowResult } from '../../trust/reject-flow.js';
+import { type Context, type ContextWith, type StoreContext } from '../types.js';
 /** Delete a memory by id. Reach is checked inside the delete's write scope, and a
  * row out of reach answers as not found, so a caller learns nothing about it. */
 export interface ForgetResult {
     ok: true;
     id: string;
 }
-export declare function forget<C extends Context>(ctx: C, id: string): StoreReply<C, ForgetResult>;
+export declare function forget(ctx: ContextWith<'entryWrites'>, id: string): Promise<ForgetResult>;
 export interface RejectOpts {
     /** By-id form: reject the CURRENT content of an existing memory. */
     memoryId?: string;
@@ -19,13 +19,15 @@ export interface RejectResult {
     digest: string;
     removedIds: string[];
 }
-/** Tombstones a value's normalized digest so a matching write is refused everywhere until `unreject`; pass exactly one of `memoryId` or `value`.
- * `memoryId` also removes every live tenant row with that digest (not others' personal rows); `reason` is required. Throws on an unknown id or both/neither. */
-export declare function reject(ctx: Context, opts: RejectOpts): Promise<RejectResult>;
-/** `hippo reject` on the host: every row it removed and the rows that kept their other texts. A personal row by id answers with the
- *  personal refusal rather than reject's not-found, as the operator can see that row. */
+/** Tombstones a value's normalized digest so a matching write is refused everywhere until `unreject`; pass exactly one
+ * of `memoryId` or `value`. `memoryId` also removes every live tenant row with that digest (not others' personal rows);
+ * `reason` is required. Throws on an unknown id or both/neither. */
+export declare function reject(ctx: StoreContext, opts: RejectOpts): Promise<RejectResult>;
+/** `hippo reject` on the host: every row it removed and the rows that kept their other texts. A personal row by id
+ * answers with the personal refusal rather than reject's not-found, as the operator can see that row. */
 export declare function rejectOnHost(ctx: Context, opts: RejectOpts): RejectFlowResult;
-/** Deletes a tombstone by exact digest or unambiguous prefix, restoring writability (the only v1 escape hatch); throws on blank, no match or several. */
+/** Deletes a tombstone by exact digest or unambiguous prefix, restoring writability (the only v1 escape hatch); throws
+ * on blank, no match or several. */
 export declare function unreject(ctx: Context, digestOrPrefix: string): {
     ok: boolean;
     digest: string;

package/dist/api/{forget.js → memories/forget.js}

@@ -1,22 +1,26 @@
 // Forget a memory, and reject or unreject a value so it cannot be stored again.
-import { BadRequestError, NotFoundError } from '../core/api-errors.js';
-import { rejectValue, unrejectValue } from '../trust/reject-flow.js';
-import { andThen, notPorted, onStore } from './on-store.js';
-import { requireHostAdmin } from './types.js';
+import { BadRequestError, NotFoundError } from '../../core/api-errors.js';
+import { rejectValue, unrejectValue } from '../../trust/reject-flow.js';
+import { requireHostAdmin } from '../types.js';
 import { getMemory } from './memories.js';
-import { canTouchScope, personalScopeOf } from '../core/recall-scope.js';
-export function forget(ctx, id) {
-    return onStore(ctx, (port) => {
-        const entryWrites = port.entryWrites ?? notPorted(port, 'entryWrites');
-        const removal = { tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor), id };
-        return andThen(entryWrites.forget(removal), () => ({ ok: true, id }));
+import { canTouchScope, personalScopeOf } from '../../core/recall-scope.js';
+export async function forget(ctx, id) {
+    const entryWrites = ctx.store.entryWrites;
+    await entryWrites.forget({
+        tenantId: ctx.tenantId,
+        actor: ctx.actor.subject,
+        ownScope: personalScopeOf(ctx.actor),
+        id,
     });
+    return { ok: true, id };
 }
-/** Tombstones a value's normalized digest so a matching write is refused everywhere until `unreject`; pass exactly one of `memoryId` or `value`.
- * `memoryId` also removes every live tenant row with that digest (not others' personal rows); `reason` is required. Throws on an unknown id or both/neither. */
+/** Tombstones a value's normalized digest so a matching write is refused everywhere until `unreject`; pass exactly one
+ * of `memoryId` or `value`. `memoryId` also removes every live tenant row with that digest (not others' personal rows);
+ * `reason` is required. Throws on an unknown id or both/neither. */
 export async function reject(ctx, opts) {
     if (opts.memoryId !== undefined) {
-        // Tenant scope: same not-found-shaped denial as forget/promote; rejectValue tenant-checks too, but pre-checking keeps the error message consistent.
+        // Tenant scope: same not-found-shaped denial as forget/promote; rejectValue tenant-checks too, but pre-checking
+        // keeps the error message consistent.
         const entry = await getMemory(ctx, opts.memoryId);
         if (entry === null || !canTouchScope(ctx.actor, entry.scope)) {
             throw new NotFoundError(`memory not found: ${opts.memoryId}`);
@@ -25,14 +29,15 @@ export async function reject(ctx, opts) {
     const result = applyReject(ctx, opts);
     return { digest: result.digest, removedIds: result.removedIds };
 }
-/** `hippo reject` on the host: every row it removed and the rows that kept their other texts. A personal row by id answers with the
- *  personal refusal rather than reject's not-found, as the operator can see that row. */
+/** `hippo reject` on the host: every row it removed and the rows that kept their other texts. A personal row by id
+ * answers with the personal refusal rather than reject's not-found, as the operator can see that row. */
 export function rejectOnHost(ctx, opts) {
     requireHostAdmin(ctx, 'Rejecting with the removal report');
     return applyReject(ctx, opts);
 }
 function applyReject(ctx, opts) {
-    // SHORTCUT: the tombstone write is hippo.db only, as the port has no rejection group; one when a served store needs reject.
+    // SHORTCUT: the tombstone write is hippo.db only, as the port has no rejection group; one when a served store needs
+    // reject.
     return rejectValue({
         hippoRoot: ctx.hippoRoot,
         tenantId: ctx.tenantId,
@@ -43,7 +48,8 @@ function applyReject(ctx, opts) {
         ownScope: personalScopeOf(ctx.actor) ?? undefined,
     });
 }
-/** Deletes a tombstone by exact digest or unambiguous prefix, restoring writability (the only v1 escape hatch); throws on blank, no match or several. */
+/** Deletes a tombstone by exact digest or unambiguous prefix, restoring writability (the only v1 escape hatch); throws
+ * on blank, no match or several. */
 export function unreject(ctx, digestOrPrefix) {
     const outcome = unrejectValue(ctx.hippoRoot, ctx.tenantId, digestOrPrefix, ctx.actor.subject);
     if (outcome.status === 'not_found') {

package/dist/api/memories/memories.d.ts

@@ -0,0 +1,27 @@
+import type { MemoryEntry } from '../../core/memory.js';
+import type { StrengthTallies } from '../../store/candidates.js';
+import { type ContextWith, type StoreContext } from '../types.js';
+/** The row `id` in the caller's tenant, or null when it is missing or another tenant's. */
+export declare function getMemory(ctx: StoreContext, id: string): Promise<MemoryEntry | null>;
+/** getMemory, but NotFound when the row is another person's
+ * personal one, so the reply does not reveal that the id exists. */
+export declare function getTouchableMemory(ctx: StoreContext, id: string): Promise<MemoryEntry | null>;
+export interface MemoryStatus extends StrengthTallies {
+    openConflicts: number;
+}
+/** Tenant-wide counts behind the status verbs: strength tallies
+ * at `now` (at risk is under `atRiskBelow`) and open conflicts. */
+export declare function getMemoryStatus(ctx: ContextWith<'reports'>, now: Date, atRiskBelow: number): Promise<MemoryStatus>;
+/** Which rows a read covers: the caller's tenant, or with `everyTenant` the whole store. */
+export interface TenantReach {
+    everyTenant?: boolean;
+}
+/** Every memory row in reach, oldest first, read `pageSize` rows per query so no single read grows with the store. */
+export declare function listMemories(ctx: ContextWith<'reports'>, reach?: TenantReach, opts?: {
+    pageSize?: number;
+}): Promise<MemoryEntry[]>;
+/** How many memory rows the whole store holds, counted in SQL. */
+export declare function countAllMemories(ctx: ContextWith<'reports'>): Promise<number>;
+/** The rows in reach among `ids`; a missing id or one out of reach is absent. */
+export declare function listMemoriesByIds(ctx: StoreContext, ids: readonly string[], reach?: TenantReach): Promise<MemoryEntry[]>;
+//# sourceMappingURL=memories.d.ts.map