hippo-memory 1.62.0 → 1.63.0

package/dist/api/context-select.js

@@ -8,14 +8,15 @@ import { rankBothStores } from '../shared.js';
 import { evalNow } from '../ablation.js';
 import { hybridSearch } from '../search/hybrid.js';
 import { physicsSearch } from '../search/physics-search.js';
+import { DEFAULT_LOCAL_BUMP } from '../search/types.js';
 import { compareScoredResults } from '../compare.js';
 import { scopeMatch } from '../scope.js';
-import { loadConfig } from '../config.js';
 import { promptTokens, contentTokens, gatePromptRecall, } from '../prompt-recall.js';
+const GLOBAL_DISCOUNT = 1 / DEFAULT_LOCAL_BUMP;
 // Share and promote copy a memory to the global store under a new id, so equal content is the only link.
 // A pinned copy wins, then the stronger one after the ranking's own global discount; a tie keeps the local copy.
 export function oneCopyPerMemory(local, global, now) {
-    const score = (e, isGlobal) => calculateStrength(e, now) * (isGlobal ? 1 / 1.2 : 1);
+    const score = (e, isGlobal) => calculateStrength(e, now) * (isGlobal ? GLOBAL_DISCOUNT : 1);
     const best = new Map();
     const offer = (entry, isGlobal) => {
         const held = best.get(entry.content);
@@ -34,10 +35,8 @@ export function oneCopyPerMemory(local, global, now) {
 }
 export const finiteOr = (v, dflt, min) => Number.isFinite(v) && v >= min ? v : dflt;
 /** Pins plus the prompt-recall or recent-N backfill; null means the block is empty. */
-export function selectPinned(ctx, opts, plan, left, pools, admission) {
-    const { obs, primaryIsGlobal } = plan;
-    // loadConfig is safe even when local isn't initialised — returns defaults.
-    const pinnedCfg = loadConfig(ctx.hippoRoot);
+export function selectPinned(opts, plan, left, pools, admission) {
+    const { obs, primaryIsGlobal, config: pinnedCfg } = plan;
     if (!pinnedCfg.pinnedInject.enabled) {
         return null;
     }
@@ -85,7 +84,7 @@ function rankPinned(plan, pinnedLocal, pinnedGlobal, nowP) {
         const sBst = scopeSig === 1 ? 1.5 : scopeSig === -1 ? 0.5 : 1.0;
         return {
             entry,
-            score: calculateStrength(entry, nowP) * (isGlobal ? 1 / 1.2 : 1) * sBst,
+            score: calculateStrength(entry, nowP) * (isGlobal ? GLOBAL_DISCOUNT : 1) * sBst,
             tokens: plan.price(entry, isGlobal),
             isGlobal,
         };
@@ -204,7 +203,7 @@ function backfillRecent(plan, localPool, globalPool, picked, recentBudget, nowP)
         .slice(0, plan.includeRecent)
         .map(({ entry, isGlobal }) => ({
         entry,
-        score: calculateStrength(entry, nowP) * (isGlobal ? 1 / 1.2 : 1),
+        score: calculateStrength(entry, nowP) * (isGlobal ? GLOBAL_DISCOUNT : 1),
         tokens: plan.price(entry, isGlobal),
         isGlobal,
     }));
@@ -225,7 +224,7 @@ export function selectStrongest(plan, left, pools) {
     const globalRanked = globalPool
         .map((e) => ({
         entry: e,
-        score: calculateStrength(e, now) * (1 / 1.2),
+        score: calculateStrength(e, now) * GLOBAL_DISCOUNT,
         tokens: plan.price(e, true),
         isGlobal: true,
     }))
@@ -275,8 +274,7 @@ function contextVectorSpec(ctx, plan, admit) {
     return { tenantId: ctx.tenantId, scope: recallScopeFilter(plan.exactScope, 'exact'), includeSuperseded: false, admit };
 }
 async function searchLocalRows(ctx, plan, left, minResults, localEntries, admit) {
-    const { cost, price, primaryIsGlobal, query } = plan;
-    const ctxConfig = loadConfig(ctx.hippoRoot);
+    const { cost, price, primaryIsGlobal, query, config: ctxConfig } = plan;
     const usePhysicsCtx = ctxConfig.physics?.enabled !== false;
     const localCost = cost && ((r) => price(r.entry, primaryIsGlobal));
     const vectorCandidates = contextVectorSpec(ctx, plan, admit);

package/dist/api/context-types.d.ts

@@ -3,22 +3,17 @@ import type { SessionHandoff } from '../handoff.js';
 import type { MemoryEntry } from '../memory.js';
 import type { DeliveryObserver } from '../delivery-recorder.js';
 import type { AmbientState } from '../ambient.js';
+import type { ProjectRef } from '../project-identity.js';
 /**
  * Options for `getContext` — assemble a budget-bounded context bundle
  * (recalled memories + active task snapshot + handoff + recent events).
- * Extracted from `cmdContext` in `cli.ts` in Episode A of the api.ts refactor.
  *
  * Named `getContext` (not `context`) to avoid collision with the `Context`
  * interface above and the ubiquitous `ctx: Context` convention. Follows the
  * existing `getEntry` naming pattern in store.ts.
  *
- * Scope narrow (T5 execute decision): rendering opts (`format`, `framing`,
- * `rendered`) and host-side opts (`auto`) are NOT included here. The print
- * helpers (`printContextMarkdown`, `printActiveTaskSnapshot`, `printHandoff`,
- * `printSessionEvents`) are shared with `cmdRecall` / `cmdSnapshot` /
- * `cmdHandoffShow` — moving them into api.ts would expand T5 to also rewire
- * those commands. CLI handles rendering + auto-resolution. Episode B can add
- * `api.renderContext` once a shared rendering need actually materializes.
+ * Rendering opts (`format`, `framing`, `rendered`) and host-side opts (`auto`) stay in the CLI,
+ * because its print helpers are shared with `cmdRecall` / `cmdSnapshot` / `cmdHandoffShow`.
  */
 export interface ContextOpts {
     q?: string;
@@ -30,7 +25,7 @@ export interface ContextOpts {
     /** Envelope scope to match exactly, as in `recall`: admits that scope even when private, after the actor's scope check. */
     exactScope?: string;
     /** With `pinnedOnly`, also inject the N most recent writes that pass the
-     *  quality floor (`isContentWorthStoring`, DF3). Filtering happens BEFORE
+     *  quality floor (`isContentWorthStoring`). Filtering happens BEFORE
      *  the take-N, so a caller asking for 5 gets 5 qualifying entries rather
      *  than 5-minus-junk; pinned entries bypass the floor. Entries are only
      *  skipped for this read, never mutated or deleted. Ignored when
@@ -40,12 +35,12 @@ export interface ContextOpts {
      *  origin partition excludes by default. They come back tagged
      *  `category: 'cross-project'` so renderers can demarcate them. */
     crossProject?: boolean;
-    /** The active project name for the origin partition ('' = not in a
-     *  project). Defaults to `resolveProjectIdentity(process.cwd()).name`;
-     *  surfaces whose process cwd is not the caller's project (HTTP server)
-     *  should pass it explicitly. */
-    currentProject?: string;
-    /** DF1 (docs/plans/2026-08-23-df1-snapshot-lifecycle.md, T2): the calling
+    /** The active project for the origin partition ('' = not in a project): a
+     *  name, or an identity whose rows may also carry its legacy folder name.
+     *  Defaults to `resolveProjectIdentity(process.cwd())`; surfaces whose
+     *  process cwd is not the caller's project (HTTP server) should pass it. */
+    currentProject?: ProjectRef;
+    /** The calling
      *  session's id. Stamped on this call's recall trace, and the owner-match input to
      *  `loadFreshActiveTaskSnapshot` — when it strictly equals the active
      *  snapshot's `session_id`, the read is unbounded (same-session
@@ -54,7 +49,7 @@ export interface ContextOpts {
      *  it just means every snapshot goes through the age check. Host-resolved
      *  (stdin payload, HIPPO_SESSION_ID, else the host's session var) so this stays host-agnostic. */
     currentSessionId?: string | null;
-    /** Z1: raw hook-payload prompt; only the pinned-only branch reads it, gated on `pinnedInject.promptRecall`. */
+    /** Raw hook-payload prompt; only the pinned-only branch reads it, gated on `pinnedInject.promptRecall`. */
     prompt?: string;
     /** What the budget pays for, from the caller that renders the block. Absent = the memory text alone. */
     cost?: ContextCost;
@@ -83,7 +78,7 @@ export interface ContextResultEntry {
     tokens: number;
     isGlobal?: boolean;
     isFreshTail?: boolean;
-    /** Z1: admitted by the prompt-recall gate, not the recent-N backfill or a pin. */
+    /** Admitted by the prompt-recall gate, not the recent-N backfill or a pin. */
     promptRecall?: boolean;
     /** v39: the entry's owning project ('' = user-global, null = legacy row). */
     origin?: string | null;

package/dist/api/context.d.ts

@@ -1,13 +1,14 @@
 import { type MemoryEntry } from '../memory.js';
+import { type ProjectRef } from '../project-identity.js';
 import type { ContextOpts, ContextResult } from './context-types.js';
 import type { Context } from './types.js';
 export { oneCopyPerMemory } from './context-select.js';
 /**
- * v39 S4: the secret half of the ambient policy on its own, for callers
+ * The secret half of the ambient policy on its own, for callers
  * that apply their own scope rule. A flagged row is only admitted inside its owning project;
  * flagged rows with no project origin never ambient-inject.
  */
-export declare function ambientSecretAdmit(e: MemoryEntry, currentProjectName: string): boolean;
+export declare function ambientSecretAdmit(e: MemoryEntry, currentProject: ProjectRef): boolean;
 /** Most rows per store a no-query context reads; past it, ranking and ambientState see the strongest by decay. */
 export declare const CONTEXT_CANDIDATE_CAP = 2000;
 /**

package/dist/api/context.js

@@ -15,7 +15,7 @@ import { writeRecallTraceAtRoot } from '../recall-trace.js';
 import { evalNow, isRecallBoostAblated } from '../ablation.js';
 import { dropHeldCopies } from '../same-text.js';
 import { loadConfig } from '../config.js';
-import { resolveProjectIdentity, classifyOriginProject, isGlobalStoreRoot } from '../project-identity.js';
+import { resolveProjectIdentity, classifyOriginProject, isGlobalStoreRoot, projectId, projectNames } from '../project-identity.js';
 import { promptTokens } from '../prompt-recall.js';
 import { detectSecret } from '../secret-detect.js';
 import { isSessionDigestRow } from '../session-digest.js';
@@ -28,36 +28,36 @@ export { oneCopyPerMemory } from './context-select.js';
  * v39: the single ambient-injection admission policy, shared by getContext
  * and the CLI-side ambient-state summary so the two cannot drift.
  *
- * - S4 secret veto is UNCONDITIONAL: neither crossProject nor
+ * - Secret veto is UNCONDITIONAL: neither crossProject nor
  *   contextProjectIsolation:false re-includes secrets. A flagged row only
  *   injects inside its owning project; flagged rows with no project origin
  *   (''/null) never ambient-inject at all. Explicit recall is unaffected -
  *   recalling a secret is a deliberate act.
- * - S2 envelope parity: private/quarantine scopes never inject unless `exactScope` names one.
- * - S3 origin partition: other-project rows are excluded unless
+ * - Envelope parity: private/quarantine scopes never inject unless `exactScope` names one.
+ * - Origin partition: other-project rows are excluded unless
  *   `includeCrossProject`.
  */
-function ambientAdmitEntry(e, currentProjectName, includeCrossProject, exactScope) {
-    if (!ambientSecretAdmit(e, currentProjectName))
+function ambientAdmitEntry(e, currentProject, includeCrossProject, exactScope) {
+    if (!ambientSecretAdmit(e, currentProject))
         return false;
     if (!passesScopeFilterForRecall(e.scope ?? null, exactScope))
         return false;
     if (includeCrossProject)
         return true;
-    return classifyOriginProject(e.origin_project, currentProjectName) !== 'cross-project';
+    return classifyOriginProject(e.origin_project, currentProject) !== 'cross-project';
 }
 /**
- * v39 S4: the secret half of the ambient policy on its own, for callers
+ * The secret half of the ambient policy on its own, for callers
  * that apply their own scope rule. A flagged row is only admitted inside its owning project;
  * flagged rows with no project origin never ambient-inject.
  */
-export function ambientSecretAdmit(e, currentProjectName) {
+export function ambientSecretAdmit(e, currentProject) {
     if (!detectSecret(e).flagged)
         return true;
     const origin = e.origin_project;
     if (origin === undefined || origin === null || origin === '')
         return false;
-    return origin === currentProjectName;
+    return projectNames(currentProject).includes(origin);
 }
 /** Most rows per store a no-query context reads; past it, ranking and ambientState see the strongest by decay. */
 export const CONTEXT_CANDIDATE_CAP = 2000;
@@ -69,7 +69,7 @@ function loadAmbientEntries(hippoRoot, tenantId, pinnedOnly, includeRecent, admi
             : loadContextCandidates(hippoRoot, tenantId, window);
         return { entries: rows.filter(admit) };
     }
-    // DF3's quality floor runs on the recent-N slice AFTER this load, so the load
+    // The quality floor runs on the recent-N slice AFTER this load, so the load
     // counts by it too, or it stops short of a store whose newest rows are junk.
     const admitAmbient = (e) => {
         if (!admit(e))
@@ -113,7 +113,7 @@ export async function getContext(ctx, opts = {}) {
         return { entries: [], tokens: 0 };
     }
     const picked = plan.pinnedOnly
-        ? selectPinned(ctx, opts, plan, sections.left, pools, admission)
+        ? selectPinned(opts, plan, sections.left, pools, admission)
         : plan.query === '*'
             ? selectStrongest(plan, sections.left, pools)
             : await selectBySearch(ctx, plan, sections.left, pools, admission);
@@ -153,13 +153,13 @@ function planContext(ctx, opts) {
     // excluded unless the caller asks for them (crossProject) or isolation is disabled.
     const config = loadConfig(ctx.hippoRoot);
     const isolationEnabled = config.contextProjectIsolation !== false;
-    const currentProjectName = opts.currentProject ?? resolveProjectIdentity(process.cwd()).name;
+    const currentProject = opts.currentProject ?? resolveProjectIdentity(process.cwd());
     const includeCrossProject = opts.crossProject === true || !isolationEnabled;
     // Decided before the ambient loads so the pinned-only FTS candidate query can share their connection.
     const promptRecallPending = pinnedOnly && Boolean(opts.prompt?.trim()) && config.pinnedInject.promptRecall === true;
     const cost = opts.cost;
     const price = (entry, isGlobal, promptRecall) => cost
-        ? cost.entry({ entry, isGlobal, promptRecall, origin: entry.origin_project ?? null, category: classifyOriginProject(entry.origin_project, currentProjectName) })
+        ? cost.entry({ entry, isGlobal, promptRecall, origin: entry.origin_project ?? null, category: classifyOriginProject(entry.origin_project, currentProject) })
         : estimateTokens(entry.content);
     return {
         pinnedOnly,
@@ -174,9 +174,9 @@ function planContext(ctx, opts) {
         primaryIsGlobal,
         hasLocalTaskState: hasLocal && !primaryIsGlobal,
         config,
-        currentProjectName,
+        currentProject,
         includeCrossProject,
-        originProject: includeCrossProject || currentProjectName === '' ? undefined : currentProjectName,
+        originProject: includeCrossProject || projectId(currentProject) === '' ? undefined : projectNames(currentProject),
         promptRecallPending,
         cost,
         price,
@@ -197,7 +197,7 @@ function promptRecallRequest(opts, plan) {
 function openBlockBudget(plan, opts, budget) {
     const { config, cost, obs, pinnedOnly, promptRecallPending } = plan;
     const blockBudget = pinnedOnly && opts.budget === undefined ? config.pinnedInject.budget : budget;
-    obs?.facts({ projectName: plan.currentProjectName, budgetTokens: blockBudget, promptRecall: promptRecallPending });
+    obs?.facts({ projectName: projectId(plan.currentProject), budgetTokens: blockBudget, promptRecall: promptRecallPending });
     if (pinnedOnly && !config.pinnedInject.enabled)
         obs?.disabled();
     return cost
@@ -261,7 +261,7 @@ function ambientAdmission(opts, plan, shownHandoff) {
             digestHiddenForHandoff = true;
             return false;
         }
-        return ambientAdmitEntry(e, plan.currentProjectName, plan.includeCrossProject, plan.exactScope);
+        return ambientAdmitEntry(e, plan.currentProject, plan.includeCrossProject, plan.exactScope);
     };
     const ownSessionId = opts.currentSessionId || '';
     // Inside admit, not after the load, so the loader's window widens past a session's own items.
@@ -316,7 +316,7 @@ function finalizeSelection(picked, plan) {
     selected = selected.map((r) => ({
         ...r,
         origin: r.entry.origin_project ?? null,
-        category: classifyOriginProject(r.entry.origin_project, plan.currentProjectName),
+        category: classifyOriginProject(r.entry.origin_project, plan.currentProject),
     }));
     obs?.selected(selected);
     return { items: selected, tokens };
@@ -369,7 +369,7 @@ function recordRetrieval(ctx, opts, plan, selected, activeSnapshot) {
     return { items, ambientState: plan.config.ambient.enabled ? readAmbientState(ctx, plan) : undefined };
 }
 function readAmbientState(ctx, plan) {
-    const filter = { exactScope: plan.exactScope, project: plan.originProject, currentProject: plan.currentProjectName, now: evalNow() };
+    const filter = { exactScope: plan.exactScope, project: plan.originProject, currentProject: projectNames(plan.currentProject), now: evalNow() };
     const roots = [...(plan.hasLocal ? [ctx.hippoRoot] : []), ...(plan.hasGlobal && !plan.primaryIsGlobal ? [plan.globalRoot] : [])];
     const tallies = roots.map((root) => loadAmbientTallies(root, ctx.tenantId, filter));
     const total = tallies.length > 0 ? tallies.reduce(addAmbientTallies) : undefined;

package/dist/api/dormant.js

@@ -63,7 +63,7 @@ export function restoreDormant(ctx, id) {
             writeEntryDbOnly(db, restored, { actor: ctx.actor.subject });
             deleteDormantRow(db, ctx.tenantId, id);
             // A restore is a labelled "forgot it, then needed it" event: the
-            // signal a learned lifecycle (ROADMAP LC3) trains on. Same transaction
+            // signal a learned lifecycle trains on. Same transaction
             // as the restore, so the label exists exactly when the restore does.
             appendAuditEvent(db, {
                 tenantId: ctx.tenantId,

package/dist/api/drill-down.d.ts

@@ -73,11 +73,11 @@ export type DrillDownOutcome = DrillDownResult | DrillDownFailure;
  * if the underlying DAG accidentally linked across scopes.
  *
  * Returns a discriminated `DrillDownOutcome`: `DrillDownResult` on success,
- * or `{failure: '...'}` for `not_found` (covers genuinely-missing AND wrong-
- * tenant, intentionally indistinguishable), `not_drillable` (id is a leaf
- * row), or `scope_blocked` (caller has no scope grant for the row's scope).
+ * or `{failure: '...'}` for `not_found` (covers genuinely-missing, wrong-
+ * tenant and scope-blocked, intentionally indistinguishable) or
+ * `not_drillable` (id is a leaf row).
  *
- * Pre-v1.6.4 returned null for all four cases. JS callers migrate via
+ * Pre-v1.6.4 returned null for all three cases. JS callers migrate via
  * `'failure' in result` checks; HTTP route maps `not_drillable` to 422.
  */
 export declare function drillDown(ctx: Context, summaryId: string, opts?: DrillDownOpts): DrillDownOutcome;

package/dist/api/drill-down.js

@@ -1,5 +1,7 @@
 // DAG drill-down from a summary to its children.
-import { readEntry, loadChildrenOf } from '../store/entry-reads.js';
+import { closeHippoDb } from '../db.js';
+import { openStore } from '../store/open.js';
+import { selectEntriesByIds, selectChildrenByParent } from '../store/entry-reads.js';
 import { estimateTokens } from '../token-ledger.js';
 import { passesScopeFilterForRecall } from '../recall-scope.js';
 /**
@@ -14,11 +16,11 @@ import { passesScopeFilterForRecall } from '../recall-scope.js';
  * if the underlying DAG accidentally linked across scopes.
  *
  * Returns a discriminated `DrillDownOutcome`: `DrillDownResult` on success,
- * or `{failure: '...'}` for `not_found` (covers genuinely-missing AND wrong-
- * tenant, intentionally indistinguishable), `not_drillable` (id is a leaf
- * row), or `scope_blocked` (caller has no scope grant for the row's scope).
+ * or `{failure: '...'}` for `not_found` (covers genuinely-missing, wrong-
+ * tenant and scope-blocked, intentionally indistinguishable) or
+ * `not_drillable` (id is a leaf row).
  *
- * Pre-v1.6.4 returned null for all four cases. JS callers migrate via
+ * Pre-v1.6.4 returned null for all three cases. JS callers migrate via
  * `'failure' in result` checks; HTTP route maps `not_drillable` to 422.
  */
 export function drillDown(ctx, summaryId, opts = {}) {
@@ -26,8 +28,17 @@ export function drillDown(ctx, summaryId, opts = {}) {
     // v0.30 / E5: depth defaults 1 (backward compat); hard cap 10 levels
     // prevents pathological deep trees. CLI/HTTP/MCP reject invalid values.
     const depth = Math.max(1, Math.min(Math.trunc(opts.depth ?? 1), 10));
-    const summary = readEntry(ctx.hippoRoot, summaryId, ctx.tenantId);
-    // No unscoped cross-tenant probe here — readEntry's null return covers
+    const db = openStore(ctx.hippoRoot);
+    try {
+        return drillDownOn(db, ctx, summaryId, depth, opts, limit);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+function drillDownOn(db, ctx, summaryId, depth, opts, limit) {
+    const summary = selectEntriesByIds(db, [summaryId], ctx.tenantId).get(summaryId) ?? null;
+    // No unscoped cross-tenant probe here: the tenant-scoped read's miss covers
     // both "doesn't exist" and "exists in another tenant" by design.
     // Distinguishing them via an unscoped lookup would leak existence to
     // unauthorised tenants. The two cases collapse into not_found.
@@ -42,7 +53,7 @@ export function drillDown(ctx, summaryId, opts = {}) {
         // already preventing. Match the HTTP behaviour at the API level.
         return { failure: 'not_found' };
     }
-    const { collected, level0DirectCount } = collectDescendants(ctx, summaryId, depth);
+    const { collected, level0DirectCount } = collectDescendants(db, ctx.tenantId, summaryId, depth);
     const summaryOut = {
         id: summary.id,
         content: summary.content,
@@ -72,15 +83,16 @@ export function drillDown(ctx, summaryId, opts = {}) {
 }
 // BFS with a visited set: dag_parent_id is not unique, so a misconfigured tree could emit a child twice past depth 1.
 // The level-0 count is kept apart so a legacy summary's descendantCount fallback counts direct children only.
-function collectDescendants(ctx, summaryId, depth) {
+function collectDescendants(db, tenantId, summaryId, depth) {
     const collected = [];
     const visited = new Set([summaryId]);
     let frontier = [summaryId];
     let level0DirectCount = 0;
     for (let level = 0; level < depth; level++) {
         const nextFrontier = [];
+        const kidsByParent = selectChildrenByParent(db, frontier, tenantId);
         for (const parentId of frontier) {
-            const kids = loadChildrenOf(ctx.hippoRoot, parentId, ctx.tenantId);
+            const kids = kidsByParent.get(parentId) ?? [];
             const eligibleKids = kids.filter((c) => passesScopeFilterForRecall(c.scope ?? null, undefined));
             for (const k of eligibleKids) {
                 if (visited.has(k.id))

package/dist/api/outcome.d.ts

@@ -8,14 +8,13 @@ import type { Context } from './types.js';
  * op='outcome' tagged with ctx.actor.subject.
  *
  * Returns `{applied, appliedIds}`. `appliedIds` is the tenant-filtered subset
- * of input ids that actually had `applyOutcome` run on them (i.e. ids whose
- * `readEntry(..., ctx.tenantId)` resolved). Callers that surface the id list
+ * of input ids that actually had `applyOutcome` run on them (i.e. ids found
+ * in ctx.tenantId). Callers that surface the id list
  * over a multi-tenant boundary (HTTP /v1/outcome last-recall path, Python SDK)
  * MUST return `appliedIds` instead of the raw input list — otherwise the
- * non-applied (cross-tenant) ids leak to the caller. Added in v1.11.4 to
- * close that disclosure path on POST /v1/outcome.
+ * non-applied (cross-tenant) ids leak to the caller.
  *
- * `opts.traceId` (LC1, docs/plans/2026-08-02-lc1-recall-trace-persistence.md):
+ * `opts.traceId`:
  * OPTIONAL additive opt so a programmatic caller can link this outcome to
  * the recall_traces row it judges. NOT applied unconditionally — an SDK
  * caller passing explicit ids with no preceding CLI/context recall would
@@ -36,18 +35,14 @@ export declare function outcome(ctx: Context, ids: ReadonlyArray<string>, good:
  *
  * Reads `loadIndex(ctx.hippoRoot).last_retrieval_ids` (per-hippoRoot local
  * state; not tenant-scoped at the index layer) and forwards to `outcome()`,
- * which DOES tenant-filter via `readEntry(..., ctx.tenantId)`. Cross-tenant
+ * which DOES tenant-filter its read by `ctx.tenantId`. Cross-tenant
  * ids in `last_retrieval_ids` are silently skipped, matching the MCP
  * `hippo_outcome` semantics.
  *
- * **Tenant-safe response shape (v1.11.4 security fix):** the returned `ids`
+ * **Tenant-safe response shape:** the returned `ids`
  * field contains ONLY the tenant-filtered subset that actually had outcomes
- * applied (i.e. `appliedIds` from the inner `outcome()` call). Earlier
- * versions returned the raw `last_retrieval_ids` regardless of tenant, which
- * leaked cross-tenant memory IDs to the caller via POST /v1/outcome's
- * no-body last-recall response. The fix is at this helper so all callers
- * (CLI cmdOutcome, HTTP /v1/outcome, MCP `hippo_outcome` if added later)
- * inherit the tenant-safe contract.
+ * applied (i.e. `appliedIds` from the inner `outcome()` call). It lives in this
+ * helper so every caller (CLI, HTTP /v1/outcome, MCP) inherits the contract.
  *
  * Do NOT tighten `loadIndex` with `tenantId` inside this helper — doing so
  * would break the (correct) cross-tenant-silent-skip behavior covered by

package/dist/api/outcome.js

@@ -1,24 +1,27 @@
 // Outcome feedback on recalled memories.
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { writeEntry } from '../store/entry-writes.js';
-import { readEntry } from '../store/entry-reads.js';
+import { closeHippoDb } from '../db.js';
+import { openStore } from '../store/open.js';
+import { writeEntryOn } from '../store/entry-writes.js';
+import { selectEntriesByIds } from '../store/entry-reads.js';
 import { loadIndex } from '../store/index-and-stats.js';
 import { applyOutcome, CHURN_STALE_TAG } from '../memory.js';
 import { appendAuditEvent } from '../audit.js';
 import { recordTraceOutcome } from '../recall-trace.js';
 export function outcome(ctx, ids, good, opts) {
     const appliedIds = [];
-    const db = openHippoDb(ctx.hippoRoot);
+    const db = openStore(ctx.hippoRoot);
     try {
+        const live = selectEntriesByIds(db, ids, ctx.tenantId);
         for (const id of ids) {
-            const entry = readEntry(ctx.hippoRoot, id, ctx.tenantId);
+            const entry = live.get(id);
             if (!entry)
                 continue;
             let updated = applyOutcome(entry, good);
-            if (good && updated.tags.includes(CHURN_STALE_TAG)) { // FE2: a good outcome reconfirms the entry
+            if (good && updated.tags.includes(CHURN_STALE_TAG)) { // a good outcome reconfirms the entry
                 updated = { ...updated, tags: updated.tags.filter((t) => t !== CHURN_STALE_TAG) };
             }
-            writeEntry(ctx.hippoRoot, updated, { actor: ctx.actor.subject });
+            writeEntryOn(db, ctx.hippoRoot, updated, { actor: ctx.actor.subject });
+            live.set(id, updated); // a repeated id builds on its first outcome, as a fresh read would
             appendAuditEvent(db, {
                 tenantId: ctx.tenantId,
                 actor: ctx.actor.subject,
@@ -28,7 +31,7 @@ export function outcome(ctx, ids, good, opts) {
             });
             appliedIds.push(id);
         }
-        // LC1: link the outcome to its trace, recording only the ids actually
+        // Link the outcome to its trace, recording only the ids actually
         // credited (post tenant-filtering, matches appliedIds). Lives in its own
         // append-only table so audit_log pruning can never erase training data.
         if (opts?.traceId !== undefined && appliedIds.length > 0) {
@@ -50,15 +53,8 @@ export function outcomeForLastRecall(ctx, good) {
     const ids = idx.last_retrieval_ids;
     if (ids.length === 0)
         return { applied: 0, ids: [] };
-    // LC1 F1(d) structural fix (docs/plans/2026-08-02-lc1-recall-trace-persistence.md):
-    // read the trace id from the SAME `loadIndex` snapshot already in hand
-    // (idx.last_trace_id) — a single-snapshot read, not a second DB round
-    // trip via a now-deleted readLastTraceId helper. The value is already
-    // strict-parsed by buildIndexFromDb's parseLastTraceId (store.ts): every
-    // consumer gets a clean positive-integer string or null, never a garbage
-    // value that could reach outcome() and INSERT trace_id=0/NaN. null on a
-    // fresh store / pre-v40 flow / api.recall-only usage — outcome() skips
-    // linkage silently when traceId is undefined.
+    // Same `loadIndex` snapshot as the ids; buildIndexFromDb already strict-parses it to a
+    // positive-integer string or null, so no trace_id=0/NaN reaches outcome().
     const traceId = idx.last_trace_id !== null ? Number(idx.last_trace_id) : null;
     const { applied, appliedIds } = outcome(ctx, ids, good, traceId !== null ? { traceId } : undefined);
     return { applied, ids: appliedIds };

package/dist/api/promote.d.ts

@@ -8,8 +8,7 @@ import type { Context } from './types.js';
  *
  * Note: `promoteToGlobal` does not currently take a tenantId override — it
  * reads the entry from the local root via `readEntry` (no tenant filter) and
- * preserves the entry's existing tenantId on the global side. Task 4 may
- * tighten this once writeEntry/readEntry thread tenant context.
+ * preserves the entry's existing tenantId on the global side.
  */
 export interface PromoteResult {
     ok: true;
@@ -19,9 +18,8 @@ export interface PromoteResult {
 export declare function promote(ctx: Context, id: string): PromoteResult;
 /**
  * Replace an old memory with new content, chaining old.superseded_by = new.id.
- * Mirrors `cmdSupersede` in cli.ts (without flag-driven layer/tag/pin overrides
- * — A1 keeps the API minimal; the CLI handler will continue to handle those
- * flags and pass the resolved values once Task 4 lands).
+ * Mirrors `cmdSupersede` in cli.ts minus the flag-driven layer/tag/pin
+ * overrides: the CLI handler resolves those so the API stays minimal.
  */
 export interface SupersedeResult {
     ok: true;
@@ -34,13 +32,12 @@ export declare function supersede(ctx: Context, oldId: string, newContent: strin
  *
  * `archiveRawMemory` audits the operation internally (op='archive_raw') using the
  * row's own tenant_id. We DO NOT emit a second audit event here to avoid double-
- * emitting the archive_raw op (unlike Task 1 remember/forget where the underlying
- * helpers hardcode actor='cli'). Instead we pass `ctx.actor.subject` through as `who`,
+ * emitting the archive_raw op. Instead we pass `ctx.actor.subject` through as `who`,
  * and raw-archive.ts uses that for the audit row.
  */
 export interface ArchiveRawOpts {
     /**
-     * Connector idempotency hook (v0.39 commit 3). Runs inside the same
+     * Connector idempotency hook. Runs inside the same
      * SAVEPOINT as the archive — throwing rolls the archive back. Used by the
      * Slack deletion connector to mark the deletion event seen atomically.
      */

package/dist/api/quarantine.js

@@ -2,7 +2,7 @@
 import { openHippoDb, closeHippoDb } from '../db.js';
 import { ConflictError, ForbiddenError, NotFoundError } from '../api-errors.js';
 import { writeEntryMirrors } from '../store/entry-writes.js';
-import { readEntry } from '../store/entry-reads.js';
+import { readEntry, selectEntriesByIds } from '../store/entry-reads.js';
 import { quarantineScopeFor, getQuarantineRow, listQuarantineRows, approveQuarantineRow, rejectQuarantineRow, } from '../quarantine.js';
 import { log } from '../log.js';
 import { appendAuditEvent } from '../audit.js';
@@ -12,8 +12,9 @@ export function quarantineList(ctx, opts = {}) {
     const db = openHippoDb(ctx.hippoRoot);
     try {
         const rows = listQuarantineRows(db, ctx.tenantId, opts.status ?? 'pending', opts.limit, opts.after);
+        const entries = selectEntriesByIds(db, rows.map((row) => row.memoryId), ctx.tenantId);
         return rows.map((row) => {
-            const entry = readEntry(ctx.hippoRoot, row.memoryId, ctx.tenantId);
+            const entry = entries.get(row.memoryId);
             return {
                 id: row.memoryId,
                 originalScope: row.originalScope,