hippo-memory 2.0.0 → 2.1.0

package/dist/util/write-budget.d.ts

@@ -3,9 +3,14 @@ export declare const TARGET_HOLD_MS = 100;
 /** SQLite's longest busy-handler sleep under a hook's 1 s wait, so a waiting hook always wakes inside the gap. */
 export declare const GAP_MS = 100;
 export declare function clock(): number;
-/** Waits until GAP_MS have passed since the last commit; always yields once, so timers and requests run between chunks. */
+/**
+ * Waits until GAP_MS have passed since the last commit; always yields once, so timers and requests run between chunks.
+ */
 export declare function pauseForWaiters(lastCommitAt: number): Promise<void>;
-/** The hold, clock and pause a chunked write runs on; a test passes its own to force chunk boundaries without real waits. */
+/**
+ * The hold, clock and pause a chunked write runs on; a test passes its own to force chunk boundaries without real
+ * waits.
+ */
 export interface WriteBudget {
     readonly holdMs: number;
     readonly clock: () => number;

package/dist/util/write-budget.js

@@ -1,4 +1,5 @@
-// How long a long-running write may hold the store's write lock per transaction, and how long it lets other writers in after.
+// How long a long-running write may hold the store's write lock per transaction, and how long it lets other writers in
+// after.
 import { setTimeout as delay } from 'node:timers/promises';
 /** A chunk closes at the first unit boundary after this long: a server request gives up after a 250 ms wait. */
 export const TARGET_HOLD_MS = 100;
@@ -7,7 +8,9 @@ export const GAP_MS = 100;
 export function clock() {
     return performance.now();
 }
-/** Waits until GAP_MS have passed since the last commit; always yields once, so timers and requests run between chunks. */
+/**
+ * Waits until GAP_MS have passed since the last commit; always yields once, so timers and requests run between chunks.
+ */
 export async function pauseForWaiters(lastCommitAt) {
     await delay(Math.max(0, GAP_MS - (clock() - lastCommitAt)));
 }

package/dist/util/yaml.d.ts

@@ -1,4 +1,7 @@
-/** Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays, enough for the MemoryEntry schema. */
+/**
+ * Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays,
+ * enough for the MemoryEntry schema.
+ */
 type YamlValue = string | number | boolean | null | string[] | number[];
 export declare function dumpFrontmatter(obj: Record<string, YamlValue>): string;
 export interface ParsedFrontmatter {

package/dist/util/yaml.js

@@ -1,4 +1,7 @@
-/** Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays, enough for the MemoryEntry schema. */
+/**
+ * Minimal YAML frontmatter serializer/deserializer with no external deps: simple key-value pairs and inline arrays,
+ * enough for the MemoryEntry schema.
+ */
 const SCALAR_LOOKALIKE = /^(null|true|false|-?\d+(\.\d+)?)$/;
 const UNESCAPES = new Map([['\\', '\\'], ['"', '"'], ['n', '\n'], ['r', '\r']]);
 function escapeString(s) {

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "2.0.0",
+  "version": "2.1.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
@@ -36,6 +36,7 @@
     "baseline": "npm run build && npm test",
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc && tsc -p tsconfig.benchmarks.json && tsc -p tsconfig.extensions.json",
     "typecheck:tests": "tsc -p tsconfig.tests.json",
+    "check:dts": "node scripts/check-dts-diff.mjs",
     "dev": "tsc --watch",
     "pretest": "npm run build",
     "test": "vitest run",

package/scripts/postinstall.cjs

@@ -11,6 +11,8 @@ if (!fs.existsSync(distPostinstall)) {
   process.exit(0);
 }
 
-import(pathToFileURL(distPostinstall).href).catch(() => {
+// A failed nudge must not fail the install, but the reason still reaches the user.
+import(pathToFileURL(distPostinstall).href).catch((err) => {
+  process.stderr.write(`hippo-memory postinstall skipped: ${err instanceof Error ? err.message : err}\n`);
   process.exit(0);
 });

package/dist/api/cards.d.ts

@@ -1,42 +0,0 @@
-import type { Card, CardComment, CardRun, CardStatus } from '../core/card.js';
-import type { HandoffOutcome } from '../core/handoff.js';
-import { type CardDetail } from '../store/card-detail.js';
-import type { Context } from './types.js';
-/** Create a card in the caller's tenant. Throws on an empty title or an unknown dependency. */
-export declare function cardCreate(ctx: Context, input: {
-    title: string;
-    repo?: string;
-    contract?: string;
-    budget?: number;
-    dependsOn?: string[];
-}): Card;
-/** One card by id, or null when the caller's tenant has none. */
-export declare function cardLoad(ctx: Context, id: string): Card | null;
-/** The card with its dependencies, runs, comments and latest handoff, or null when unknown. */
-export declare function cardDetail(ctx: Context, id: string): CardDetail | null;
-/** The caller's cards, newest-updated first, optionally filtered to one status. */
-export declare function cardList(ctx: Context, opts?: {
-    status?: CardStatus;
-}): Card[];
-/** Every run of a card, newest first. */
-export declare function cardRuns(ctx: Context, id: string): CardRun[];
-/** Claim a ready or blocked card for a runtime; null when it cannot be claimed. */
-export declare function cardClaim(ctx: Context, id: string, runtime: string, sessionId?: string): (Card & {
-    runId: number;
-}) | null;
-/** Extend a live run's lease; null when the run is not live. */
-export declare function cardHeartbeat(ctx: Context, id: string, runId: number): Card | null;
-/** Block a running card with a reason; null when it is not running. */
-export declare function cardBlock(ctx: Context, id: string, reason: string, runId?: number): Card | null;
-/** Move a running card to review; null when it is not running. */
-export declare function cardReview(ctx: Context, id: string, runId?: number): Card | null;
-/** Complete a card in review and promote the children it unblocks; null when not in review. */
-export declare function cardComplete(ctx: Context, id: string, outcome: HandoffOutcome, runId?: number): {
-    card: Card;
-    promotedChildren: string[];
-} | null;
-/** Return every card with an expired lease to ready; yields the reclaimed ids. */
-export declare function cardReclaimExpired(ctx: Context): string[];
-/** Add a comment to a card. Throws on an empty body. */
-export declare function cardComment(ctx: Context, cardId: string, author: string, body: string): CardComment;
-//# sourceMappingURL=cards.d.ts.map

package/dist/api/conflicts.d.ts

@@ -1,28 +0,0 @@
-import type { MemoryConflict } from '../store/rows.js';
-import type { CallerProject } from './prompt-hook.js';
-import { type Context } 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: Context, conflictId: number, opts: ResolveMemoryConflictOpts): 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: Context, project?: CallerProject): 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: Context, status: string, reach?: TenantReach): MemoryConflict[];
-//# sourceMappingURL=conflicts.d.ts.map

package/dist/api/conflicts.js

@@ -1,61 +0,0 @@
-// Conflict resolution for every front end, so the reach, status, pair and liveness checks live in one place.
-// SHORTCUT: hippo.db only, since the store port has no conflict calls; a conflicts group when a served store needs them.
-import { BadRequestError, ConflictError, NotFoundError } from '../core/api-errors.js';
-import { listMemoryConflicts, listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
-import { loadEntriesByIds } from '../store/entry-reads.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 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 conflict = listTouchableConflicts(ctx.hippoRoot, '*', ctx.tenantId, ctx.actor).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 (loadEntriesByIds(ctx.hippoRoot, pair, ctx.tenantId).filter(isLive).length < pair.length) {
-        throw new NotFoundError(`conflict ${conflictId} names a memory that is superseded, archived or quarantined`);
-    }
-    const resolved = resolveConflict(ctx.hippoRoot, { conflictId, keepId: opts.keepId, forgetLoser: opts.forget === true, tenantId: ctx.tenantId }, {
-        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 function listOpenConflicts(ctx, project) {
-    const touchable = listTouchableConflicts(ctx.hippoRoot, 'open', ctx.tenantId, 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]))];
-    // loadEntriesByIds reads at most one chunk of ids per call.
-    const rows = new Map(chunked(ids).flatMap((chunk) => loadEntriesByIds(ctx.hippoRoot, chunk, ctx.tenantId)).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 function listConflicts(ctx, status, reach = {}) {
-    requireHostAdmin(ctx, 'Listing conflicts past the scope check');
-    return listMemoryConflicts(ctx.hippoRoot, status, reach.everyTenant ? undefined : ctx.tenantId);
-}
-//# sourceMappingURL=conflicts.js.map

package/dist/api/dormant.d.ts

@@ -1,14 +0,0 @@
-import { type DormantMemory, type ListDormantOpts } from '../store/dormant.js';
-import { type MemoryEntry } from '../core/memory.js';
-import type { Context } from './types.js';
-/** A tenant's dormant memories (src/store/dormant.ts): what sleep moved out of active memory when `dormant.enabled` is on. Newest first;
- * `opts.query` keeps rows containing every term (case-insensitive). */
-export declare function listDormant(ctx: Context, opts?: ListDormantOpts): DormantMemory[];
-/** Restores a dormant memory as if just recalled, with a full half-life; a row set aside by audit repair returns `verified`.
- * Throws if the tenant has no such dormant id or a live memory holds it, and RejectedValueError if the value was since rejected (the dormant copy stays). */
-export declare function restoreDormant(ctx: Context, id: string): MemoryEntry;
-/** Permanently deletes a dormant memory, the explicit "forget it for good"; throws when the tenant has no dormant memory with that id. */
-export declare function forgetDormant(ctx: Context, id: string): void;
-/** Whether the tenant holds a dormant memory with this id that the caller may touch (for "not found" hints). */
-export declare function isDormant(ctx: Context, id: string): boolean;
-//# sourceMappingURL=dormant.d.ts.map

package/dist/api/dormant.js

@@ -1,58 +0,0 @@
-// Dormant memories: list, restore, forget and check.
-import { ConflictError, NotFoundError } from '../core/api-errors.js';
-import { stampOriginProject } from '../store/entry-row.js';
-import { updateStatsUnlessBusy } from '../store/index-and-stats.js';
-import { loadDormantMemories, holdsDormantMemory, restoreDormantMemory, forgetDormantMemory, } from '../store/dormant.js';
-import { strengthAblation } from '../core/ablation.js';
-import { createMemory, calculateStrength } from '../core/memory.js';
-import { loadConfig } from '../core/config.js';
-import { canTouchScope, personalScopeOf } from '../core/recall-scope.js';
-import { touchableScopeSql } from '../store/rule-sql.js';
-const touchable = (ctx) => touchableScopeSql('', personalScopeOf(ctx.actor));
-/** A tenant's dormant memories (src/store/dormant.ts): what sleep moved out of active memory when `dormant.enabled` is on. Newest first;
- * `opts.query` keeps rows containing every term (case-insensitive). */
-export function listDormant(ctx, opts = {}) {
-    return loadDormantMemories(ctx.hippoRoot, ctx.tenantId, opts, touchable(ctx));
-}
-/** Restores a dormant memory as if just recalled, with a full half-life; a row set aside by audit repair returns `verified`.
- * Throws if the tenant has no such dormant id or a live memory holds it, and RejectedValueError if the value was since rejected (the dormant copy stays). */
-export function restoreDormant(ctx, id) {
-    const outcome = restoreDormantMemory(ctx.hippoRoot, {
-        tenantId: ctx.tenantId,
-        id,
-        actor: ctx.actor.subject,
-        inReach: (scope) => canTouchScope(ctx.actor, scope),
-        revive: (snapshot, now) => reviveSnapshot(ctx, snapshot, now),
-    });
-    if (outcome.status === 'missing')
-        throw new NotFoundError(`dormant memory not found: ${id}`);
-    if (outcome.status === 'active') {
-        throw new ConflictError(`memory ${id} is already active; forget it before restoring its dormant copy`);
-    }
-    return outcome.entry;
-}
-function reviveSnapshot(ctx, dormant, now) {
-    // A snapshot can predate a field added later: createMemory supplies defaults, then the snapshot overrides every field it carries.
-    // The placeholder content only meets createMemory's minimum length, so a legacy row under 3 chars still restores.
-    const revived = {
-        ...createMemory('dormant snapshot defaults', { baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays }),
-        ...dormant.entry,
-        last_retrieved: now.toISOString(),
-    };
-    if (dormant.reason === 'quality-repair')
-        revived.confidence = 'verified';
-    return stampOriginProject(ctx.hippoRoot, { ...revived, strength: calculateStrength(revived, now, { ablation: strengthAblation() }) });
-}
-/** Permanently deletes a dormant memory, the explicit "forget it for good"; throws when the tenant has no dormant memory with that id. */
-export function forgetDormant(ctx, id) {
-    const forgotten = forgetDormantMemory(ctx.hippoRoot, { tenantId: ctx.tenantId, id, actor: ctx.actor.subject, admit: touchable(ctx) });
-    if (!forgotten)
-        throw new NotFoundError(`dormant memory not found: ${id}`);
-    // Counted like every other permanent removal (forget, archiveRaw).
-    updateStatsUnlessBusy(ctx.hippoRoot, { forgotten: 1 }, `removed ${id}`);
-}
-/** Whether the tenant holds a dormant memory with this id that the caller may touch (for "not found" hints). */
-export function isDormant(ctx, id) {
-    return holdsDormantMemory(ctx.hippoRoot, ctx.tenantId, id, touchable(ctx));
-}
-//# sourceMappingURL=dormant.js.map

package/dist/api/goals.d.ts

@@ -1,18 +0,0 @@
-import { type CompleteGoalOpts, type Goal, type PushGoalOpts } from '../store/goals.js';
-import { type Context } from './types.js';
-/** What a new goal carries; its tenant is always the caller's. */
-export type GoalPushOpts = Omit<PushGoalOpts, 'tenantId'>;
-/** Push a goal onto `sessionId`'s stack in the caller's tenant. */
-export declare function goalPush(ctx: Context, opts: GoalPushOpts): Goal;
-/** The caller's goals for `sessionId`: active ones, or every status when `all` is set. */
-export declare function goalList(ctx: Context, opts: {
-    sessionId: string;
-    all: boolean;
-}): Goal[];
-/** Complete a goal by id; a no-op for an unknown or already completed goal. Host admin only. */
-export declare function goalComplete(ctx: Context, goalId: string, opts: CompleteGoalOpts): void;
-/** Suspend an active goal by id. Host admin only. */
-export declare function goalSuspend(ctx: Context, goalId: string): void;
-/** Resume a suspended goal by id, suspending the oldest active one past the depth cap. Host admin only. */
-export declare function goalResume(ctx: Context, goalId: string): void;
-//# sourceMappingURL=goals.d.ts.map

package/dist/api/graph.d.ts

@@ -1,8 +0,0 @@
-import type { GraphRows } from '../store/port.js';
-import type { Context } from './types.js';
-/** The entity/relation rows behind GET /v1/graph, as the caller's role, scopes and owner may see them. */
-export declare function graphRows(ctx: Context, query: {
-    entity?: string;
-    limit: number;
-}): Promise<GraphRows>;
-//# sourceMappingURL=graph.d.ts.map

package/dist/api/graph.js

@@ -1,8 +0,0 @@
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
-/** The entity/relation rows behind GET /v1/graph, as the caller's role, scopes and owner may see them. */
-export async function graphRows(ctx, query) {
-    const { role, scopes, owner } = ctx.actor;
-    return requireGroup(storeFor(ctx), 'graphReads').graphRows(ctx.tenantId, { ...query, reader: { role, scopes, owner } });
-}
-//# sourceMappingURL=graph.js.map

package/dist/api/learn.js

@@ -1,125 +0,0 @@
-// Git auto-learn: fix/revert/bug commit subjects become memories. `hippo learn`, init, sleep and MCP hippo_learn share it.
-import { ForbiddenError } from '../core/api-errors.js';
-import { fetchGitLog, extractLessons, partitionLessons, isGitRepo } from '../learn/autolearn.js';
-import { loadConfig } from '../core/config.js';
-import { runWithRequestStores } from '../db/request-stores.js';
-import { embedMemory } from '../search/embed-memories.js';
-import { extractInvalidationTarget, invalidateMatching, invalidateMatchingAmong, } from '../learn/invalidation.js';
-import { createMemory, Layer, schemaFitFrom, schemaFitSourceOf } from '../core/memory.js';
-import { extractPathTags } from '../search/path-context.js';
-import { canReadScope, personalScopeOf } from '../core/recall-scope.js';
-import { duplicateKey, longestWord, storedTextKeys } from '../util/same-text.js';
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
-// SHORTCUT: two profiles keep each surface's rows as they were; fold MCP onto the CLI profile once it may invalidate.
-export const CLI_LEARN = Object.freeze({ tags: Object.freeze(['error', 'git-learned']), source: 'git-learn', full: true });
-export const MCP_LEARN = Object.freeze({ tags: Object.freeze(['git-learned']), source: 'git', full: false });
-/** Learn from `repoPath`'s last `days` of commits into the caller's tenant. Host admin only. */
-export async function learn(ctx, opts) {
-    // It reads the host's own git history, which belongs to the host, not to the caller's tenant.
-    if (!ctx.actor.hostAdmin)
-        throw new ForbiddenError('hippo_learn requires a host admin');
-    const none = { added: 0, skipped: 0, rejected: 0, lowInfo: 0, invalidations: [] };
-    if (!isGitRepo(opts.repoPath))
-        return { status: 'not-a-repo', ...none };
-    const gitLog = fetchGitLog(opts.repoPath, opts.days);
-    if (!gitLog.trim())
-        return { status: 'no-commits', ...none };
-    const config = loadConfig(ctx.hippoRoot);
-    const parsed = extractLessons(gitLog, config.gitLearnPatterns);
-    if (parsed.length === 0)
-        return { status: 'no-lessons', ...none };
-    // The gate filters the loop input, so a dropped lesson neither stores nor invalidates; docs/decisions git-learn-gate-placement says why.
-    const { kept, dropped } = partitionLessons(parsed);
-    return { status: 'scanned', lowInfo: dropped.length, ...await writeLessons(ctx, kept, opts, config) };
-}
-/** Writes `queued` in one transaction; a refused lesson is dropped from `live` and `keys` and must not abort the rest of the git-log scan. */
-async function landLessons(batch, queued) {
-    if (queued.length === 0)
-        return;
-    const { ctx, writes, live, keys, counts } = batch;
-    const written = new Set(await writes.writeSkippingRejected(queued.map((q) => q.entry), ctx.actor.subject));
-    const landed = [];
-    for (const { entry, key } of queued) {
-        if (written.has(entry.id)) {
-            landed.push(entry);
-            continue;
-        }
-        counts.rejected++;
-        keys.delete(key);
-        const at = live.indexOf(entry);
-        if (at !== -1)
-            live.splice(at, 1);
-    }
-    counts.added += landed.length;
-    if (!batch.full)
-        return;
-    if (landed.length > 0)
-        await writes.bumpRemembered(landed.length);
-    for (const entry of landed)
-        void embedMemory(ctx.hippoRoot, entry, undefined, ctx.store);
-}
-/** The duplicate keys a batch skips: every readable row's with `existing`, else only the rows holding a lesson's longest word. */
-async function knownKeys(ctx, writes, lessons, existing) {
-    return storedTextKeys(existing ?? await writes.textsHoldingWords(ctx.tenantId, lessons.map(longestWord), personalScopeOf(ctx.actor)));
-}
-async function writeLessons(ctx, lessons, opts, config) {
-    const { tenantId } = ctx;
-    const { profile } = opts;
-    const store = storeFor(ctx);
-    const writes = requireGroup(store, 'lessonWrites');
-    // `hippo init` calls this outside any request, so the batch brings its own scope: every read and write below shares one handle.
-    return runWithRequestStores(async () => {
-        // One read serves the batch: invalidation matches against `live`, which follows every write below, as a reload per lesson did.
-        const live = profile.full ? await writes.tenantEntries(tenantId) : [];
-        // Schema fit needs every row; without it, only rows holding a lesson's longest word can be its copy. Learn is host-admin only, so
-        // both read what an admin can.
-        const existing = profile.full ? live.filter((e) => e.scope == null || canReadScope(ctx.actor, e.scope)) : undefined;
-        // Each lesson is scored against `existing` as it was before the batch, so its tag counts and texts are read once.
-        const fitSource = existing && schemaFitSourceOf(existing);
-        const batch = {
-            ctx, writes, live, keys: await knownKeys(ctx, writes, lessons, existing), full: profile.full,
-            counts: { added: 0, skipped: 0, rejected: 0, invalidations: [] },
-        };
-        const pathTags = profile.full ? extractPathTags(opts.repoPath) : [];
-        // Lessons queue and land in one transaction; an invalidation reads the store, so it flushes the queue first.
-        const queue = [];
-        for (const lesson of lessons) {
-            const key = duplicateKey(lesson);
-            if (batch.keys.has(key)) {
-                batch.counts.skipped++;
-                continue;
-            }
-            const target = profile.full ? extractInvalidationTarget(lesson) : null;
-            if (target) {
-                await landLessons(batch, queue.splice(0));
-                const { invalidated } = await invalidateMatchingAmong(store, live, target, tenantId);
-                if (invalidated > 0)
-                    batch.counts.invalidations.push({ from: target.from, count: invalidated });
-            }
-            const entry = createMemory(lesson, {
-                layer: Layer.Episodic,
-                tags: [...profile.tags],
-                source: profile.source,
-                confidence: 'observed',
-                schema_fit: fitSource && schemaFitFrom(lesson, [...profile.tags], fitSource),
-                tenantId,
-                baseHalfLifeDays: config.defaultHalfLifeDays,
-            });
-            for (const tag of pathTags)
-                if (!entry.tags.includes(tag))
-                    entry.tags.push(tag);
-            queue.push({ entry, key });
-            if (profile.full)
-                live.push(entry);
-            batch.keys.add(key);
-        }
-        await landLessons(batch, queue.splice(0));
-        return batch.counts;
-    });
-}
-/** `hippo invalidate`: weakens the caller's tenant's memories that reference `target.from`, or only the one `options.onlyId` names. */
-export function invalidateMemories(ctx, target, options) {
-    return invalidateMatching(ctx.hippoRoot, target, ctx.tenantId, options);
-}
-//# sourceMappingURL=learn.js.map

package/dist/api/memories.d.ts

@@ -1,25 +0,0 @@
-import type { MemoryEntry } from '../core/memory.js';
-import { type StrengthTallies } from '../store/candidates.js';
-import { type Context } 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: Context, 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: Context, 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: Context, now: Date, atRiskBelow: number): 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: Context, reach?: TenantReach, opts?: {
-    pageSize?: number;
-}): MemoryEntry[];
-/** How many memory rows the whole store holds, counted in SQL. */
-export declare function countAllMemories(ctx: Context): number;
-/** The rows in reach among `ids`; a missing id or one out of reach is absent. */
-export declare function listMemoriesByIds(ctx: Context, ids: readonly string[], reach?: TenantReach): MemoryEntry[];
-//# sourceMappingURL=memories.d.ts.map

package/dist/api/objects.d.ts

@@ -1,9 +0,0 @@
-import type { SavableDescriptor } from '../objects/descriptor.js';
-import type { ObjectByKind, SavableKind } from '../core/object-types.js';
-import type { Objects } from '../store/port.js';
-import type { Context } from './types.js';
-/** The request store's object group; the dispatcher has already answered 501 for a store without it. */
-export declare function objectsOf(ctx: Context): Objects;
-/** Saves through the request's store as the authenticated caller. */
-export declare function saveFor<K extends SavableKind, W>(ctx: Context, d: SavableDescriptor<K, W>, write: W): Promise<ObjectByKind[K]>;
-//# sourceMappingURL=objects.d.ts.map

package/dist/api/outcome.d.ts

@@ -1,19 +0,0 @@
-import type { Context } from './types.js';
-/** An id outside ctx.tenantId, or in someone else's personal scope, is skipped, so a stale id never fails the call.
- *  `appliedIds` holds only the ids applied: a caller that answers across tenants returns it, never the ids it was sent. */
-export interface OutcomeResult {
-    applied: number;
-    appliedIds: string[];
-}
-/** `opts.traceId` links the outcome to the recall trace it judges. Only outcomeForLastRecall sends one: explicit ids may follow no recall at all. */
-export declare function outcome(ctx: Context, ids: ReadonlyArray<string>, good: boolean, opts?: {
-    traceId?: number;
-}): Promise<OutcomeResult>;
-/** The last recall's ids and its trace sit with the store's lastRecall group, which only the CLI and context write; a store without it is refused.
- *  `ids` holds only the ids applied in ctx.tenantId: the index is not tenant-scoped, so the ids read from it are never returned. */
-export interface OutcomeForLastRecallResult {
-    applied: number;
-    ids: string[];
-}
-export declare function outcomeForLastRecall(ctx: Context, good: boolean): Promise<OutcomeForLastRecallResult>;
-//# sourceMappingURL=outcome.d.ts.map

package/dist/api/predictions.d.ts

@@ -1,11 +0,0 @@
-import { type Prediction, type PredictionBaserate, type SavePredictionOpts } from '../store/predictions.js';
-import type { PredictionClose, PredictionSave, Predictions } from '../store/port.js';
-import type { Context } from './types.js';
-export declare function savePrediction(ctx: Context, input: PredictionSave): Promise<Prediction>;
-/** A claim saved with its recall mirror, built under the store root's half-life as the HTTP create route builds it. */
-export declare function recordPrediction(ctx: Context, claim: SavePredictionOpts): Promise<Prediction>;
-export declare function listPredictions(ctx: Context, query: Parameters<Predictions['listPredictions']>[1]): Promise<Prediction[]>;
-export declare function predictionBaserate(ctx: Context, classTag: string): Promise<PredictionBaserate>;
-export declare function predictionById(ctx: Context, id: number): Promise<Prediction | null>;
-export declare function closePrediction(ctx: Context, id: number, close: PredictionClose): Promise<Prediction>;
-//# sourceMappingURL=predictions.d.ts.map

package/dist/api/promote.d.ts

@@ -1,36 +0,0 @@
-import type { ConnectorEvent } from '../store/port.js';
-import { type Layer } from '../core/memory.js';
-import type { Context } from './types.js';
-/** Copies a local memory into the global store; the inner writeEntry emits 'remember' there, and we add a 'promote' audit event so intent stays distinct.
- * promoteToGlobal reads via `readEntry` with no tenant filter and keeps the entry's existing tenantId on the global side. */
-export interface PromoteResult {
-    ok: true;
-    sourceId: string;
-    globalId: string;
-}
-export declare function promote(ctx: Context, id: string): PromoteResult;
-/** Replace an old memory with new content, chaining old.superseded_by = new.id; the store commits both rows and the audit row together. */
-export interface SupersedeResult {
-    ok: true;
-    oldId: string;
-    newId: string;
-}
-/** What the successor takes instead of the old row's value. Never set from a request body: the CLI fills it from its flags. */
-export interface SupersedeOverrides {
-    layer?: Layer;
-    tags?: string[];
-    pinned?: boolean;
-}
-export declare function supersede(ctx: Context, oldId: string, newContent: string, overrides?: SupersedeOverrides): Promise<SupersedeResult>;
-/** Archive a kind='raw' memory: its metadata moves to raw_archive and the row is
- * deleted. The store writes the one archive_raw audit row, under the caller's subject. */
-export interface ArchiveRawOpts {
-    /** The connector event this archive answers. The store logs it in the archive's own transaction, so a redelivery finds it logged. */
-    event?: ConnectorEvent;
-}
-export interface ArchiveRawResult {
-    ok: true;
-    archivedAt: string;
-}
-export declare function archiveRaw(ctx: Context, id: string, reason: string, opts?: ArchiveRawOpts): Promise<ArchiveRawResult>;
-//# sourceMappingURL=promote.d.ts.map

package/dist/api/recall-core.d.ts

@@ -1,4 +0,0 @@
-import type { CliCoreRanker, RecallOpts, RecallResult } from './recall-types.js';
-import type { Context } from './types.js';
-export declare function retrieveWithCliCore(ctx: Context, opts: RecallOpts, core: CliCoreRanker): Promise<RecallResult>;
-//# sourceMappingURL=recall-core.d.ts.map