hippo-memory 1.72.0 → 2.1.0

package/dist/api/memories/memories.js

@@ -0,0 +1,52 @@
+import { NotFoundError } from '../../core/api-errors.js';
+import { canTouchScope } from '../../core/recall-scope.js';
+import { requireHostAdmin } from '../types.js';
+/** The row `id` in the caller's tenant, or null when it is missing or another tenant's. */
+export async function getMemory(ctx, id) {
+    const [entry] = await ctx.store.entriesByIds([id], ctx.tenantId);
+    return entry ?? null;
+}
+/** getMemory, but NotFound when the row is another person's
+ * personal one, so the reply does not reveal that the id exists. */
+export async function getTouchableMemory(ctx, id) {
+    const entry = await getMemory(ctx, id);
+    if (!canTouchScope(ctx.actor, entry?.scope ?? null))
+        throw new NotFoundError(`Memory not found: ${id}`);
+    return entry;
+}
+/** Tenant-wide counts behind the status verbs: strength tallies
+ * at `now` (at risk is under `atRiskBelow`) and open conflicts. */
+export function getMemoryStatus(ctx, now, atRiskBelow) {
+    return ctx.store.reports.memoryStatus(ctx.tenantId, now, atRiskBelow);
+}
+function tenantFilter(ctx, reach) {
+    if (!reach.everyTenant)
+        return ctx.tenantId;
+    requireHostAdmin(ctx, 'Reading every tenant');
+    return undefined;
+}
+/** Rows a listing reads per query by default; the verbs still receive every row. */
+const LIST_PAGE_SIZE = 1000;
+/** Every memory row in reach, oldest first, read `pageSize` rows per query so no single read grows with the store. */
+export async function listMemories(ctx, reach = {}, opts = {}) {
+    const tenant = tenantFilter(ctx, reach) ?? null;
+    const limit = Math.max(1, Math.trunc(opts.pageSize ?? LIST_PAGE_SIZE));
+    const all = [];
+    let after;
+    do {
+        const page = await ctx.store.reports.entriesPage(tenant, { limit, after });
+        all.push(...page.entries);
+        after = page.next ?? undefined;
+    } while (after);
+    return all;
+}
+/** How many memory rows the whole store holds, counted in SQL. */
+export async function countAllMemories(ctx) {
+    requireHostAdmin(ctx, 'Reading every tenant');
+    return ctx.store.reports.countEntries();
+}
+/** The rows in reach among `ids`; a missing id or one out of reach is absent. */
+export async function listMemoriesByIds(ctx, ids, reach = {}) {
+    return ctx.store.entriesByIds(ids, tenantFilter(ctx, reach));
+}
+//# sourceMappingURL=memories.js.map

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

@@ -0,0 +1,22 @@
+import type { ContextWith, StoreContext } 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: ContextWith<'entryWrites'>, 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: StoreContext, good: boolean): Promise<OutcomeForLastRecallResult>;
+//# sourceMappingURL=outcome.d.ts.map

package/dist/api/memories/outcome.js

@@ -0,0 +1,28 @@
+// Outcome feedback on recalled memories.
+import { personalScopeOf } from '../../core/recall-scope.js';
+import { HttpError } from '../../util/http-util.js';
+import { narrowStore } from '../../store/index.js';
+/** `opts.traceId` links the outcome to the recall trace it judges. Only outcomeForLastRecall sends one: explicit ids
+ * may follow no recall at all. */
+export async function outcome(ctx, ids, good, opts) {
+    const store = ctx.store;
+    const entryWrites = store.entryWrites;
+    const write = { tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor), ids, good };
+    const traceId = opts?.traceId;
+    // Recall traces live beside the last recall, so only a store with the lastRecall group can link one.
+    const appliedIds = traceId === undefined
+        ? await entryWrites.applyOutcome(write)
+        : await narrowStore(store, 'lastRecall').lastRecall.applyTracedOutcome(write, traceId);
+    return { applied: appliedIds.length, appliedIds };
+}
+export async function outcomeForLastRecall(ctx, good) {
+    const lastRecall = ctx.store.lastRecall;
+    // Its own 501 text, since a client of such a store can still
+    // apply the outcome by sending the ids its recall returned.
+    if (lastRecall === undefined) {
+        throw new HttpError(501, 'this store keeps no last recall: send the ids your recall returned');
+    }
+    const ids = await lastRecall.applyOutcomeToLast({ tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor) }, good);
+    return { applied: ids.length, ids };
+}
+//# sourceMappingURL=outcome.js.map

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

@@ -0,0 +1,40 @@
+import type { ConnectorEvent } from '../../store/port.js';
+import { type Layer } from '../../core/memory.js';
+import type { ContextWith } 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: ContextWith<'localFiles'>, 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: ContextWith<'entryWrites'>, 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: ContextWith<'entryWrites'>, id: string, reason: string, opts?: ArchiveRawOpts): Promise<ArchiveRawResult>;
+//# sourceMappingURL=promote.d.ts.map

package/dist/api/memories/promote.js

@@ -0,0 +1,76 @@
+// Promote to the global store, supersede with a successor, and archive raw memories.
+import { ConflictError, NotFoundError } from '../../core/api-errors.js';
+import { stampOriginProject } from '../../store/entry-row.js';
+import { createSuccessor } from '../../core/memory.js';
+import { embedGlobalCopy } from '../../sharing/global-store.js';
+import { configOf } from '../config-of.js';
+import { narrowStore } from '../../store/index.js';
+import { canTouchScope, personalScopeOf } from '../../core/recall-scope.js';
+export function promote(ctx, id) {
+    const { promotion } = ctx.store.localFiles;
+    // promoteToGlobal reads without a tenant filter, so pre-check the row's tenant_id and deny cross-tenant access with
+    // archiveRaw's not-found wording (no leak about whether the id exists in another tenant).
+    const reach = promotion.reach(id);
+    if (reach?.tenantId !== ctx.tenantId || !canTouchScope(ctx.actor, reach.scope)) {
+        throw new NotFoundError(`memory not found: ${id}`);
+    }
+    // The 'promote' row commits with the global copy, so no write
+    // follows the commit and a busy store fails the whole promote.
+    const globalEntry = promotion.copyToGlobal(id, {
+        actor: ctx.actor.subject,
+        tenantId: ctx.tenantId,
+        auditAs: { tenantId: ctx.tenantId, actor: ctx.actor.subject },
+    });
+    embedGlobalCopy(globalEntry);
+    return { ok: true, sourceId: id, globalId: globalEntry.id };
+}
+export async function supersede(ctx, oldId, newContent, overrides = {}) {
+    const store = ctx.store;
+    const entryWrites = store.entryWrites;
+    const [old] = await store.entriesByIds([oldId], ctx.tenantId);
+    const newEntry = createSuccessor(assertSupersedable(ctx, oldId, old ?? null), newContent, {
+        tenantId: ctx.tenantId,
+        baseHalfLifeDays: configOf(ctx).defaultHalfLifeDays,
+        layer: overrides.layer,
+        tags: overrides.tags,
+        pinned: overrides.pinned,
+    });
+    // A store writes origin_project as given, so the served folder's fallback is stamped here.
+    const successor = stampOriginProject(ctx.hippoRoot, newEntry);
+    await entryWrites.supersede({
+        tenantId: ctx.tenantId,
+        actor: ctx.actor.subject,
+        ownScope: personalScopeOf(ctx.actor),
+        oldId,
+        successor,
+    });
+    return { ok: true, oldId, newId: successor.id };
+}
+/** The tenant-scoped row to supersede; another tenant's id, or someone else's personal row, reads as not found. */
+function assertSupersedable(ctx, oldId, old) {
+    if (!old || !canTouchScope(ctx.actor, old.scope ?? null)) {
+        throw new NotFoundError(`Memory not found: ${oldId}`);
+    }
+    // The CAS UPDATE closes the race; this check only gives a clearer error in the common single-writer case.
+    if (old.superseded_by) {
+        throw new ConflictError(`Memory ${oldId} is already superseded by ${old.superseded_by}. Supersede that one instead.`);
+    }
+    return old;
+}
+export async function archiveRaw(ctx, id, reason, opts = {}) {
+    const store = ctx.store;
+    const entryWrites = store.entryWrites;
+    const archive = {
+        tenantId: ctx.tenantId,
+        actor: ctx.actor.subject,
+        ownScope: personalScopeOf(ctx.actor),
+        id,
+        reason,
+    };
+    const { event } = opts;
+    const archivedAt = event
+        ? await narrowStore(store, 'connectorWrites').connectorWrites.archiveConnectorEntry({ ...archive, event })
+        : await entryWrites.archiveRaw(archive);
+    return { ok: true, archivedAt };
+}
+//# sourceMappingURL=promote.js.map

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

@@ -0,0 +1,10 @@
+import type { MemoryEntry } from '../../core/memory.js';
+import type { ContextWith } from '../types.js';
+/** Marks a merged memory a model has rewritten, so a later pass skips it. */
+export declare const REFINED_TAG = "llm-refined";
+/**
+ * Store a model's rewrite of a merged memory: the new text replaces the old one, and the row gains the refined tag
+ * once.
+ */
+export declare function storeRefinement(ctx: ContextWith<'entryWrites'>, entry: MemoryEntry, refined: string): Promise<void>;
+//# sourceMappingURL=refine.d.ts.map

package/dist/api/memories/refine.js

@@ -0,0 +1,12 @@
+// The write half of `hippo refine`: the model call stays with the caller, the rewritten row is stored here.
+/** Marks a merged memory a model has rewritten, so a later pass skips it. */
+export const REFINED_TAG = 'llm-refined';
+/**
+ * Store a model's rewrite of a merged memory: the new text replaces the old one, and the row gains the refined tag
+ * once.
+ */
+export async function storeRefinement(ctx, entry, refined) {
+    const tags = entry.tags.includes(REFINED_TAG) ? entry.tags : [...entry.tags, REFINED_TAG];
+    await ctx.store.entryWrites.writeEntry({ entry: { ...entry, content: refined, tags }, actor: ctx.actor.subject });
+}
+//# sourceMappingURL=refine.js.map

package/dist/api/{remember-local.d.ts → memories/remember-local.d.ts}

@@ -1,11 +1,13 @@
-import type { ConfidenceLevel, Layer, MemoryEntry, MemoryKind } from '../core/memory.js';
-import type { HippoDbContext } from './types.js';
+import type { ConfidenceLevel, Layer, MemoryEntry, MemoryKind } from '../../core/memory.js';
+import { type EmbedOutcome } from '../../search/embed-memories.js';
+import type { ContextWith, StoreContext } from '../types.js';
 /** One write by a caller in this process, every field already parsed and checked by it. */
 export interface LocalRememberInput {
     readonly content: string;
     /** Every tag the row stores; the salience gate reads these. */
     readonly tags: readonly string[];
-    /** The tags schema fit is scored on, for a caller that added path and scope tags of its own to `tags`; without it, `tags`. */
+    /** The tags schema fit is scored on, for a caller that added
+     * path and scope tags of its own to `tags`; without it, `tags`. */
     readonly fitTags?: readonly string[];
     readonly kind?: MemoryKind;
     readonly scope?: string;
@@ -23,18 +25,22 @@ export interface StartedWeak {
     readonly reason: string;
     readonly strength: number;
 }
-/** `stored` carries the row as the store holds it after the write; `skipped` is the gate dropping the write, with nothing stored or counted. */
+/** `stored` carries the row as the store holds it after the write, and `embedding`, which settles with whether the row
+ * reached the vector index (a caller may ignore it; a failure is also logged). `skipped` is the gate dropping the
+ * write, with nothing stored or counted. */
 export type LocalRememberOutcome = {
     readonly status: 'stored';
     readonly entry: MemoryEntry;
+    readonly embedding: Promise<EmbedOutcome>;
     readonly startedWeak?: StartedWeak;
 } | {
     readonly status: 'skipped';
     readonly reason: string;
     readonly score: number;
 };
-/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A refused value throws as `remember` does. */
-export declare function rememberLocally(ctx: HippoDbContext, input: LocalRememberInput): LocalRememberOutcome;
+/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A
+ * refused value throws as `remember` does. */
+export declare function rememberLocally(ctx: ContextWith<'entryWrites'>, input: LocalRememberInput): Promise<LocalRememberOutcome>;
 /** What a caller asks of fact extraction. The key comes from the caller, which read it from its own environment. */
 export interface FactExtractionRequest {
     /** The caller asked for extraction (`--extract`); the store's config can turn it on without that. */
@@ -42,7 +48,8 @@ export interface FactExtractionRequest {
     readonly apiKey?: string;
     readonly fetcher?: typeof fetch;
 }
-/** `off`: nobody asked. `no_key`: asked, with no key to call the model. `ran`: the facts the model gave and each reason it gave fewer. */
+/** `off`: nobody asked. `no_key`: asked, with no key to call the model. `ran`: the facts the model gave and each reason
+ * it gave fewer. */
 export type FactExtraction = {
     readonly status: 'off';
 } | {
@@ -52,6 +59,7 @@ export type FactExtraction = {
     readonly facts: number;
     readonly failures: readonly string[];
 };
-/** Extracts facts from a row just stored and stores them beside it. Best-effort: a failure is named in the result, never thrown. */
-export declare function extractRememberedFacts(ctx: HippoDbContext, entry: MemoryEntry, request: FactExtractionRequest): Promise<FactExtraction>;
+/** Extracts facts from a row just stored and stores them beside it.
+ * Best-effort: a failure is named in the result, never thrown. */
+export declare function extractRememberedFacts(ctx: StoreContext, entry: MemoryEntry, request: FactExtractionRequest): Promise<FactExtraction>;
 //# sourceMappingURL=remember-local.d.ts.map

package/dist/api/{remember-local.js → memories/remember-local.js}

@@ -1,21 +1,24 @@
-// The local remember pipeline for a caller in this process (`hippo remember`, `hippo watch`): schema fit, the salience gate, the
-// write, the read-back, the `remembered` counter and the embedding kick-off, in that order. Fact extraction is a second step,
-// which the caller runs after it has reported the write. Nothing here prints; the caller reports from what comes back.
-import { loadConfig } from '../core/config.js';
-import { computeSalience } from '../core/salience.js';
-import { loadNewestEntries, schemaFitInStore } from '../store/candidates.js';
-import { embedMemory } from '../search/embed-memories.js';
-import { loadAllEntries, readEntry } from '../store/entry-reads.js';
-import { updateStats } from '../store/index-and-stats.js';
-import { errorMessage } from '../util/log.js';
+// The local remember pipeline for a caller in this process (`hippo remember`, `hippo watch`): schema fit, the salience
+// gate, the write, the read-back, the `remembered` counter and the embedding kick-off, in that order. Fact extraction
+// is a second step, which the caller runs after it has reported the write. Nothing here prints; the caller reports from
+// what comes back.
+import { configOf } from '../config-of.js';
+import { computeSalience } from '../../core/salience.js';
+import { loadNewestEntries, schemaFitInStore } from '../../store/candidates.js';
+import { embedMemory } from '../../search/embed-memories.js';
+import { loadAllEntries, readEntry } from '../../store/entry-reads.js';
+import { updateStats } from '../../store/index-and-stats.js';
+import { errorMessage, log } from '../../util/log.js';
 import { remember } from './remember.js';
 const WEAK_HALF_LIFE_FACTOR = 0.5;
-/** The gate's verdict on one write, or null where it does not judge: the store has it off, or the write is pinned or forced. */
+/** The gate's verdict on one write, or null where it does not
+ * judge: the store has it off, or the write is pinned or forced. */
 function salienceVerdict(ctx, input) {
-    const { salience } = loadConfig(ctx.hippoRoot);
+    const { salience } = configOf(ctx);
     if (!salience.enabled || input.pinned || input.force)
         return null;
-    // computeSalience compares against the last `recentWindow` rows only; below 1 its slice takes every row, so that case still loads them all.
+    // computeSalience compares against the last `recentWindow` rows only; below 1 its slice takes every row, so that case
+    // still loads them all.
     const window = Math.trunc(salience.recentWindow);
     const recent = Number.isSafeInteger(window) && window >= 1
         ? loadNewestEntries(ctx.hippoRoot, ctx.tenantId, window)
@@ -27,21 +30,33 @@ function salienceVerdict(ctx, input) {
         maxRepeatErrors: salience.maxRepeatErrors,
     });
 }
-/** The row `remember` just wrote, as the store holds it: the report, the embedding and the extraction all work on that. */
+/** The row `remember` just wrote, as the store holds it: the
+ * report, the embedding and the extraction all work on that. */
 function storedEntry(ctx, id) {
     const entry = readEntry(ctx.hippoRoot, id, ctx.tenantId);
     if (!entry)
         throw new Error(`memory ${id} was written but cannot be read back`);
     return entry;
 }
-/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A refused value throws as `remember` does. */
-export function rememberLocally(ctx, input) {
+/** Best-effort and slow (a model load or a network call), so the
+ * caller is not held for it; a row left out of the index is logged. */
+function indexInBackground(hippoRoot, entry) {
+    return embedMemory(hippoRoot, entry).then((outcome) => {
+        if (outcome === 'failed') {
+            log.warn(`memory ${entry.id} is stored but not in the vector index, so recall by meaning will miss it; run 'hippo embed' to index it`);
+        }
+        return outcome;
+    });
+}
+/** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A
+ * refused value throws as `remember` does. */
+export async function rememberLocally(ctx, input) {
     const schemaFit = schemaFitInStore(ctx.hippoRoot, ctx.tenantId, input.content, input.fitTags ?? input.tags);
     const verdict = salienceVerdict(ctx, input);
     if (verdict?.decision === 'skip')
         return { status: 'skipped', reason: verdict.reason, score: verdict.score };
     const startedWeak = verdict?.decision === 'start_weak' ? { reason: verdict.reason, strength: verdict.score } : undefined;
-    const { id } = remember(ctx, {
+    const { id } = await remember(ctx, {
         content: input.content,
         kind: input.kind,
         scope: input.scope,
@@ -59,13 +74,13 @@ export function rememberLocally(ctx, input) {
     });
     const entry = storedEntry(ctx, id);
     updateStats(ctx.hippoRoot, { remembered: 1 });
-    // Best-effort and slow (a model load or a network call), so the caller is not held for it.
-    void embedMemory(ctx.hippoRoot, entry);
-    return startedWeak ? { status: 'stored', entry, startedWeak } : { status: 'stored', entry };
+    const embedding = indexInBackground(ctx.hippoRoot, entry);
+    return startedWeak ? { status: 'stored', entry, embedding, startedWeak } : { status: 'stored', entry, embedding };
 }
-/** Extracts facts from a row just stored and stores them beside it. Best-effort: a failure is named in the result, never thrown. */
+/** Extracts facts from a row just stored and stores them beside it.
+ * Best-effort: a failure is named in the result, never thrown. */
 export async function extractRememberedFacts(ctx, entry, request) {
-    const { extraction } = loadConfig(ctx.hippoRoot);
+    const { extraction } = configOf(ctx);
     if (!request.requested && extraction.enabled !== true)
         return { status: 'off' };
     const { apiKey, fetcher } = request;
@@ -75,8 +90,15 @@ export async function extractRememberedFacts(ctx, entry, request) {
     let facts = 0;
     try {
         // Loaded on demand, so a write that extracts nothing does not pay for the module.
-        const { extractFacts, storeExtractedFacts } = await import('../learn/extract.js');
-        const found = await extractFacts(entry.content, { apiKey, model: extraction.model, fetcher, onError: (msg) => { failures.push(msg); } });
+        const { extractFacts, storeExtractedFacts } = await import('../../learn/extract.js');
+        const found = await extractFacts(entry.content, {
+            apiKey,
+            model: extraction.model,
+            fetcher,
+            onError: (msg) => {
+                failures.push(msg);
+            },
+        });
         if (found.length > 0) {
             storeExtractedFacts(ctx.hippoRoot, entry, found);
             facts = found.length;

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

@@ -1,6 +1,6 @@
-import type { ConnectorEvent } from '../store/port.js';
-import { type ConfidenceLevel, type Layer, type MemoryKind, type TraceOutcome } from '../core/memory.js';
-import type { Context, StoreReply } from './types.js';
+import type { ConnectorEvent } from '../../store/port.js';
+import { type ConfidenceLevel, type Layer, type MemoryKind, type TraceOutcome } from '../../core/memory.js';
+import type { ContextWith } from '../types.js';
 /** Row fields the caller's own process decides, as the CLI does from its flags and its salience gate. */
 export interface RememberLocal {
     layer?: Layer;
@@ -10,7 +10,8 @@ export interface RememberLocal {
     schemaFit?: number;
     traceOutcome?: TraceOutcome;
     sourceSessionId?: string | null;
-    /** A salience gate's start-weak verdict: the row starts at `strength`, and its half-life is multiplied by `halfLifeFactor`, never below one day. */
+    /** A salience gate's start-weak verdict: the row starts at `strength`, and its half-life is multiplied by
+     * `halfLifeFactor`, never below one day. */
     weaken?: {
         readonly strength: number;
         readonly halfLifeFactor: number;
@@ -23,37 +24,45 @@ export interface RememberOpts {
     owner?: string;
     artifactRef?: string;
     tags?: string[];
-    /** The connector event this write answers. The store logs it in the memory's own transaction; an event logged before stores nothing and
-     * answers `duplicate`. */
+    /** The connector event this write answers. The store logs it in the memory's own transaction; an event logged before
+     * stores nothing and answers `duplicate`. */
     event?: ConnectorEvent;
     /** Connector-ingested content an agent doesn't control; gates detectInstruction. CLI/HTTP/MCP never set this. */
     untrusted?: boolean;
-    /** The caller's project: its name becomes the row's origin. Without it the store's fallback applies (NULL on a shared store). */
+    /** The caller's project: its name becomes the row's origin. Without
+     * it the store's fallback applies (NULL on a shared store). */
     project?: {
         readonly name: string;
         readonly aliases?: readonly string[];
     };
-    /** Store it in the caller's own personal scope, readable by its owner alone in every project; needs an owner on the actor and no `scope`. */
+    /** Store it in the caller's own personal scope, readable by its owner alone in every project; needs an owner on the
+     * actor and no `scope`. */
     personal?: boolean;
-    /** Never set from a request body: a route or tool that copied it would let a client pin a row or pick its layer and source. */
+    /** Never set from a request body: a route or tool that copied it
+     * would let a client pin a row or pick its layer and source. */
     local?: RememberLocal;
 }
 export interface RememberResult {
     id: string;
     kind: MemoryKind;
     tenantId: string;
+    /** The row as written, so a caller can show it without reading it back. */
+    halfLifeDays: number;
+    tags: string[];
     /** Set only when untrusted content was flagged and quarantined instead of stored under its requested scope. */
     quarantined?: {
         reason: string;
     };
     /** Set only when the content held secret material: untrusted text had it redacted, typed text was stored as sent. */
     warnings?: string[];
-    /** Set only when the write's event was logged before: nothing was stored, so `id` names no row; `memoryId` is the id the first write logged. */
+    /** Set only when the write's event was logged before: nothing was stored, so `id` names no row; `memoryId` is the id
+     * the first write logged. */
     duplicate?: {
         memoryId: string | null;
     };
 }
-/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
- *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
-export declare function remember<C extends Context>(ctx: C, opts: RememberOpts): StoreReply<C, RememberResult>;
+/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's
+ * subject. A write that carries a connector event or untrusted content goes through connectorWrites, which commits its
+ * companion rows with it. */
+export declare function remember(ctx: ContextWith<'entryWrites'>, opts: RememberOpts): Promise<RememberResult>;
 //# sourceMappingURL=remember.d.ts.map

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

@@ -1,15 +1,16 @@
 // Write path: remember stores one memory after secret vetting and, for untrusted content, the instruction check.
-import { stampOriginProject } from '../store/entry-row.js';
-import { detectInstruction } from './instruction-detect.js';
-import { quarantineScopeFor } from '../trust/quarantine.js';
-import { createMemory } from '../core/memory.js';
-import { loadConfig } from '../core/config.js';
-import { vetSecrets } from '../util/secret-detect.js';
-import { assertCallerProject } from '../core/project-identity.js';
-import { BadRequestError } from '../core/api-errors.js';
-import { assertClientScope, personalScopeOf } from '../core/recall-scope.js';
-import { andThen, notPorted, onStore } from './on-store.js';
-/** The scope a write lands in: the caller's own personal scope when asked for, else the client's, which may not be a personal one. */
+import { stampOriginProject } from '../../store/entry-row.js';
+import { detectInstruction } from '../instruction-detect.js';
+import { quarantineScopeFor } from '../../trust/quarantine.js';
+import { createMemory, } from '../../core/memory.js';
+import { configOf } from '../config-of.js';
+import { vetSecrets } from '../../util/secret-detect.js';
+import { assertCallerProject } from '../../core/project-identity.js';
+import { BadRequestError } from '../../core/api-errors.js';
+import { assertClientScope, personalScopeOf } from '../../core/recall-scope.js';
+import { narrowStore } from '../../store/index.js';
+/** The scope a write lands in: the caller's own personal scope when
+ * asked for, else the client's, which may not be a personal one. */
 function rememberScope(ctx, opts) {
     if (!opts.personal) {
         assertClientScope(opts.scope);
@@ -38,29 +39,40 @@ function prepareRemember(ctx, opts) {
         pinned: local.pinned,
         confidence: local.confidence,
         source: local.source,
-        schema_fit: local.schemaFit,
-        trace_outcome: local.traceOutcome,
-        source_session_id: local.sourceSessionId,
+        schemaFit: local.schemaFit,
+        traceOutcome: local.traceOutcome,
+        sourceSessionId: local.sourceSessionId,
         kind: opts.kind ?? 'distilled',
         scope: detection.flagged ? quarantineScopeFor(requestedScope) : requestedScope,
         owner: opts.owner ?? null,
-        artifact_ref: opts.artifactRef ?? null,
+        artifactRef: opts.artifactRef ?? null,
         tags: opts.tags,
         tenantId: ctx.tenantId,
-        baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
+        baseHalfLifeDays: configOf(ctx).defaultHalfLifeDays,
     });
     const entry = local.weaken ? weakened(created, local.weaken) : created;
-    // Aliases only widen what a reader matches; a row has one origin. A personal row's '' follows its owner into every project.
+    // Aliases only widen what a reader matches; a row has one origin.
+    // A personal row's '' follows its owner into every project.
     const origin = opts.personal ? '' : opts.project?.name;
     const stamped = origin !== undefined ? { ...entry, origin_project: origin } : entry;
     return { entry: stamped, requestedScope, detection, warnings: vetted.warnings };
 }
 function weakened(entry, weaken) {
-    return { ...entry, strength: weaken.strength, half_life_days: Math.max(1, entry.half_life_days * weaken.halfLifeFactor) };
+    return {
+        ...entry,
+        strength: weaken.strength,
+        half_life_days: Math.max(1, entry.half_life_days * weaken.halfLifeFactor),
+    };
 }
 function rememberResult(ctx, prepared, written) {
     const { entry, detection, warnings } = prepared;
-    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId };
+    const result = {
+        id: entry.id,
+        kind: entry.kind,
+        tenantId: ctx.tenantId,
+        halfLifeDays: entry.half_life_days,
+        tags: [...entry.tags],
+    };
     if (detection.flagged)
         result.quarantined = { reason: detection.reason ?? 'unknown' };
     if (warnings.length > 0)
@@ -73,19 +85,25 @@ function rememberResult(ctx, prepared, written) {
 function quarantineOf({ requestedScope, detection }) {
     return detection.flagged ? { originalScope: requestedScope, reason: detection.reason ?? 'unknown' } : undefined;
 }
-/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
- *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
-export function remember(ctx, opts) {
-    return onStore(ctx, (port) => {
-        const entryWrites = port.entryWrites ?? notPorted(port, 'entryWrites');
-        const prepared = prepareRemember(ctx, opts);
-        // A store writes origin_project as given, so the served folder's fallback is stamped here.
-        const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
-        if (opts.untrusted !== true && opts.event === undefined)
-            return andThen(entryWrites.writeEntry(write), () => rememberResult(ctx, prepared));
-        const connectorWrites = port.connectorWrites ?? notPorted(port, 'connectorWrites');
-        const written = connectorWrites.writeConnectorEntry({ ...write, event: opts.event, quarantine: quarantineOf(prepared) });
-        return andThen(written, (outcome) => rememberResult(ctx, prepared, outcome));
+/** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's
+ * subject. A write that carries a connector event or untrusted content goes through connectorWrites, which commits its
+ * companion rows with it. */
+export async function remember(ctx, opts) {
+    const store = ctx.store;
+    const entryWrites = store.entryWrites;
+    const prepared = prepareRemember(ctx, opts);
+    // A store writes origin_project as given, so the served folder's fallback is stamped here.
+    const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
+    if (opts.untrusted !== true && opts.event === undefined) {
+        await entryWrites.writeEntry(write);
+        return rememberResult(ctx, prepared);
+    }
+    const connectorWrites = narrowStore(store, 'connectorWrites').connectorWrites;
+    const written = await connectorWrites.writeConnectorEntry({
+        ...write,
+        event: opts.event,
+        quarantine: quarantineOf(prepared),
     });
+    return rememberResult(ctx, prepared, written);
 }
 //# sourceMappingURL=remember.js.map