hippo-memory 1.62.0 → 1.63.0

package/dist/recall-scope.js

@@ -1,8 +1,7 @@
 /**
- * v1.25.0 — recall-side scope predicates, extracted from api.ts into a leaf
- * module so shared.ts (which api.ts imports) can apply the same default-deny
- * rule to searchBothHybrid's internal candidate loads without an import
- * cycle. Mirrors the v39 `project-identity.ts` precedent. api.ts imports
+ * Recall-side scope predicates, in a leaf module so shared.ts (which api.ts
+ * imports) can apply the same default-deny rule to searchBothHybrid's internal
+ * candidate loads without an import cycle. api.ts imports
  * these for its own call sites AND re-exports them for back-compat
  * (`api.isPrivateScope`, test imports of `passesScopeFilterForRecall`).
  */
@@ -35,7 +34,7 @@ export function assertNonEmpty(arr, name) {
 }
 assertNonEmpty(RECALL_DEFAULT_DENY_SCOPES, 'RECALL_DEFAULT_DENY_SCOPES');
 /**
- * v1.2.1: source-agnostic private-scope detector. A scope string is treated
+ * Source-agnostic private-scope detector. A scope string is treated
  * as private when it has the shape `<lowercase-source>:private:<rest>`.
  *
  * Examples that match:
@@ -68,7 +67,7 @@ export function isPrivateScope(scope) {
  *   `<source>:private:*` scope and on the `RECALL_DEFAULT_DENY_SCOPES`
  *   quarantine buckets. `null` and public scopes pass.
  *
- * @internal v1.7.2 — exported for test parity with
+ * @internal Exported for test parity with
  * `RECALL_DEFAULT_DENY_SCOPES` (single-source-of-truth verification). NOT part
  * of the public API surface; not re-exported from `src/index.ts`. Subject to
  * change without semver bump.
@@ -80,7 +79,7 @@ export function passesScopeFilterForRecall(scope, requested) {
     return !isRestrictedScope(scope);
 }
 /**
- * v1.25.0 — the CLI `--scope` variant of the recall filter (JS half of the
+ * The CLI `--scope` variant of the recall filter (JS half of the
  * SQL 'default-deny-or-exact' mode in loadSearchRows).
  *
  * The CLI flag predates the envelope column as a TAG-boost ranking hint
@@ -135,7 +134,7 @@ export function canReadScope(actor, scope) {
         return true;
     return (actor.scopes ?? []).includes(scope);
 }
-/** Authorize an explicitly requested scope before any read honours it (ROADMAP Part VIII EI2: member scope grants). */
+/** Authorize an explicitly requested scope before any read honours it (member scope grants). */
 export function assertScopeRequestAllowed(actor, requested) {
     if (requested === undefined || requested === '')
         return;

package/dist/recall-trace.d.ts

@@ -1,6 +1,5 @@
 /**
- * LC1 — retrieval-trace persistence
- * (docs/plans/2026-08-02-lc1-recall-trace-persistence.md).
+ * Retrieval-trace persistence.
  *
  * Single producer for the `recall_traces` / `recall_trace_results` /
  * `recall_trace_outcomes` tables (schema v40). Every recall on the three
@@ -59,14 +58,11 @@ export declare function writeRecallTrace(db: DatabaseSyncLike, input: RecallTrac
  * Used at api.getContext and CLI cmdRecall — sites where the block's own
  * convention is per-call handles (writeEntry, saveIndex) and the earlier
  * audit handles are already closed. NOT used by api.recall, which must
- * reuse the caller's open handle (v1.11.5 no-side-effects contract,
+ * reuse the caller's open handle (no-side-effects contract,
  * tests/api-recall-no-side-effects.test.ts).
  *
- * F1 structural fix (replaces the earlier stamp-then-clear design): this
- * function does NOT touch the `last_trace_id` meta key. Stamping lived here
- * originally, on its own connection, separate from the `last_retrieval_ids`
- * write in `saveIndex` — two connections meant two commits, so a crash or
- * a failed second write could advance one without the other. LOCKSTEP
+ * This function does NOT touch the `last_trace_id` meta key: its own connection
+ * would commit apart from `saveIndex`, so a crash could advance one key alone. LOCKSTEP
  * INVARIANT: `last_trace_id` must only ever advance in the SAME write as
  * `last_retrieval_ids`. The caller now does: call this function FIRST, set
  * `localIndex.last_trace_id` from the returned id, THEN call `saveIndex`
@@ -98,7 +94,7 @@ export interface RecordTraceOutcomeInput {
  * Lives in its own append-only table, not audit_log metadata: audit_log is
  * pruned by `pruneAuditLog`, and pruning must never erase training data.
  *
- * F4 validation (codex cross-model finding): `traceId`/`memoryIds` reach
+ * Validation: `traceId`/`memoryIds` reach
  * this function from caller-side state (`last_trace_id` / applied outcome
  * ids) that can go stale relative to the trace it names — a forgotten
  * memory, a tenant switch mid-session, or a race between two callers. Two

package/dist/recall-trace.js

@@ -1,6 +1,5 @@
 /**
- * LC1 — retrieval-trace persistence
- * (docs/plans/2026-08-02-lc1-recall-trace-persistence.md).
+ * Retrieval-trace persistence.
  *
  * Single producer for the `recall_traces` / `recall_trace_results` /
  * `recall_trace_outcomes` tables (schema v40). Every recall on the three
@@ -21,7 +20,7 @@ import { DELIVERY_LEDGER_VERSION } from './delivery-recorder.js';
 import { log } from './log.js';
 /**
  * Strip a RerankStep down to {stage, multiplier, scoreBefore, scoreAfter}
- * before persisting (F3 privacy fix, codex cross-model finding). `note` is
+ * before persisting. `note` is
  * free-form human text — the CLI's goal-boost step embeds matched goal tag
  * text there, so persisting it verbatim would leak raw user content into
  * training data via `rerank_json`. Only the four structured fields survive;
@@ -89,14 +88,11 @@ export function writeRecallTrace(db, input) {
  * Used at api.getContext and CLI cmdRecall — sites where the block's own
  * convention is per-call handles (writeEntry, saveIndex) and the earlier
  * audit handles are already closed. NOT used by api.recall, which must
- * reuse the caller's open handle (v1.11.5 no-side-effects contract,
+ * reuse the caller's open handle (no-side-effects contract,
  * tests/api-recall-no-side-effects.test.ts).
  *
- * F1 structural fix (replaces the earlier stamp-then-clear design): this
- * function does NOT touch the `last_trace_id` meta key. Stamping lived here
- * originally, on its own connection, separate from the `last_retrieval_ids`
- * write in `saveIndex` — two connections meant two commits, so a crash or
- * a failed second write could advance one without the other. LOCKSTEP
+ * This function does NOT touch the `last_trace_id` meta key: its own connection
+ * would commit apart from `saveIndex`, so a crash could advance one key alone. LOCKSTEP
  * INVARIANT: `last_trace_id` must only ever advance in the SAME write as
  * `last_retrieval_ids`. The caller now does: call this function FIRST, set
  * `localIndex.last_trace_id` from the returned id, THEN call `saveIndex`
@@ -135,7 +131,7 @@ export function writeRecallTraceAtRoot(root, input) {
  * Lives in its own append-only table, not audit_log metadata: audit_log is
  * pruned by `pruneAuditLog`, and pruning must never erase training data.
  *
- * F4 validation (codex cross-model finding): `traceId`/`memoryIds` reach
+ * Validation: `traceId`/`memoryIds` reach
  * this function from caller-side state (`last_trace_id` / applied outcome
  * ids) that can go stale relative to the trace it names — a forgotten
  * memory, a tenant switch mid-session, or a race between two callers. Two

package/dist/refine-llm.d.ts

@@ -23,7 +23,7 @@ export interface RefineOptions {
     /** Injected for testing — defaults to the real fetch. */
     fetcher?: typeof fetch;
     /**
-     * L9: tenant scope. When provided, refineStore only scans consolidated
+     * Tenant scope. When provided, refineStore only scans consolidated
      * entries belonging to this tenant, and parent lookups are scoped to the
      * same tenant. Cross-tenant parents return null from readEntry and are
      * silently skipped (refine still produces output from merged content).

package/dist/refine-llm.js

@@ -109,7 +109,7 @@ export async function refineStore(hippoRoot, opts) {
         failed: 0,
         details: [],
     };
-    // L9: when opts.tenantId is provided, scope the top-level scan to this
+    // When opts.tenantId is provided, scope the top-level scan to this
     // tenant's consolidated entries.
     const entries = loadAllEntries(hippoRoot, opts.tenantId);
     let processed = 0;
@@ -130,7 +130,7 @@ export async function refineStore(hippoRoot, opts) {
         const sources = [];
         const parentIds = Array.isArray(entry.parents) ? entry.parents : [];
         for (const pid of parentIds) {
-            // L9: parent lookup scoped by opts.tenantId when provided.
+            // Parent lookup scoped by opts.tenantId when provided.
             // Cross-tenant parents return null and are silently skipped — refine
             // still produces output from the merged content alone (graceful
             // degradation rather than refuse-to-refine).

package/dist/reject-flow.d.ts

@@ -1,6 +1,5 @@
 /**
- * AT1 rejected-value tombstone — shared reject/unreject/list flow.
- * docs/plans/2026-08-15-at1-rejected-value-tombstone.md (T2, plan §4).
+ * Rejected-value tombstone: shared reject/unreject/list flow.
  *
  * The CLI (`hippo reject`/`rejections`/`unreject`) and the Context-based
  * `api.reject`/`api.unreject`/`api.listRejections` surfaces both need the
@@ -24,12 +23,12 @@ export interface RejectFlowOpts {
 }
 export interface RejectFlowResult {
     digest: string;
-    /** The rejected content, for the CLI's at-reject-time echo (plan §2: the
+    /** The rejected content, for the CLI's at-reject-time echo (the
      *  tombstone itself stores no content — this is the only place it's seen
      *  again after this call returns). */
     content: string;
     /** Every row removed this call, live or dormant: all whose normalized digest matched (not just the id
-     *  passed, per the K1/R7 duplicate lesson), and each sleep-merged row holding the value, whose other
+     *  passed, since duplicates share a digest), and each sleep-merged row holding the value, whose other
      *  texts move to a new row: listed in successorIds when it was live, dormantSuccessorIds when dormant. */
     removedIds: string[];
     /** Subset of removedIds that were kind='raw' (archived, not deleted). */

package/dist/reject-flow.js

@@ -1,6 +1,5 @@
 /**
- * AT1 rejected-value tombstone — shared reject/unreject/list flow.
- * docs/plans/2026-08-15-at1-rejected-value-tombstone.md (T2, plan §4).
+ * Rejected-value tombstone: shared reject/unreject/list flow.
  *
  * The CLI (`hippo reject`/`rejections`/`unreject`) and the Context-based
  * `api.reject`/`api.unreject`/`api.listRejections` surfaces both need the
@@ -24,16 +23,7 @@ import { deleteEntryCore } from './store/delete-and-batch.js';
 import { heldTexts } from './same-text.js';
 import { mergedSuccessor } from './merged-row.js';
 import { rejectionDigest, normalizeValueForRejection, insertRejectedValue, deleteRejectedValue, listRejectedValues, } from './rejection.js';
-/**
- * `hippo reject` / `api.reject` core flow. ONE connection, one transaction:
- * insert the tombstone, enumerate + remove every live tenant row whose
- * normalized digest matches (kind-aware), one aggregate `reject_value`
- * audit, COMMIT. Then post-commit (mirrors the existing purge+reaper
- * pattern verbatim from api.archiveRaw, api.ts:1913-1938): best-effort
- * mirror purge per removed id, `mirror_cleaned_at` stamps for raw ids.
- * index.json itself is only refreshed by `rebuildIndex()`.
- */
-export function rejectValue(opts) {
+function assertRejectOpts(opts) {
     if (!opts.reason.trim()) {
         throw new Error('reject requires a non-empty --reason (the tombstone stores no content; reason is its only identity).');
     }
@@ -41,10 +31,8 @@ export function rejectValue(opts) {
         throw new Error('reject requires either a memory id or --value.');
     }
     if (opts.memoryId !== undefined && opts.value !== undefined) {
-        // P2 fix: the CLI's flag parser already refuses both forms together;
-        // the shared flow itself didn't enforce it, so a direct api caller
-        // passing both silently got the memoryId path with `value` ignored —
-        // surprising for a caller who thought they were rejecting `value`.
+        // Enforced here, not only in the CLI parser, so a direct api caller passing both
+        // is refused instead of silently getting the memoryId path with `value` ignored.
         throw new Error('reject accepts either a memory id or --value, not both.');
     }
     if (opts.value !== undefined && normalizeValueForRejection(opts.value).length === 0) {
@@ -53,28 +41,122 @@ export function rejectValue(opts) {
         // and pollute the listing.
         throw new Error('reject --value requires non-empty content.');
     }
-    const db = openStore(opts.hippoRoot);
-    try {
-        let content;
-        if (opts.memoryId !== undefined) {
-            // SAFETY: row's shape matches the two columns named in the SELECT above.
-            const row = db
-                .prepare(`SELECT content, tenant_id FROM memories WHERE id = ?`)
-                .get(opts.memoryId);
-            if (!row || row.tenant_id !== opts.tenantId) {
-                throw new Error(`memory not found: ${opts.memoryId}`);
-            }
-            content = row.content;
+}
+function contentToReject(db, opts) {
+    if (opts.memoryId === undefined)
+        return opts.value;
+    // SAFETY: row's shape matches the two columns named in the SELECT above.
+    const row = db
+        .prepare(`SELECT content, tenant_id FROM memories WHERE id = ?`)
+        .get(opts.memoryId);
+    if (!row || row.tenant_id !== opts.tenantId) {
+        throw new Error(`memory not found: ${opts.memoryId}`);
+    }
+    return row.content;
+}
+function removeLiveRows(db, opts, holdsValue, removal) {
+    const { removedIds, removedRawIds, successors } = removal;
+    const merged = [];
+    for (const row of selectAllEntries(db, opts.tenantId)) {
+        if (!holdsValue(row.content)) {
+            if (heldTexts(row).some(holdsValue))
+                merged.push(row);
+            continue;
+        }
+        if (row.kind === 'raw') {
+            // Append-only trigger respected — archiveRawMemory is the only
+            // legitimate removal path for kind='raw', and its inner SAVEPOINT
+            // composes safely inside this BEGIN/COMMIT.
+            archiveRawMemory(db, row.id, { reason: opts.reason, who: opts.actor });
+            removedRawIds.push(row.id);
         }
         else {
-            content = opts.value;
+            // suppressForgetAudit: the aggregate reject_value row below is the
+            // trail for these removals, not N individual forget rows.
+            deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
+        }
+        removedIds.push(row.id);
+    }
+    for (const row of merged) {
+        const successor = mergedSuccessor(row, holdsValue, new Set(removedIds));
+        deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
+        removedIds.push(row.id);
+        if (!successor)
+            continue;
+        const kept = stampOriginProject(opts.hippoRoot, successor);
+        writeEntryDbOnly(db, kept, { actor: opts.actor });
+        successors.push(kept);
+    }
+}
+// Dormant copies (src/dormant.ts), whole or inside a merged row, go too, in the same transaction: a
+// rejected value may not linger where `hippo dormant restore` could
+// bring it back. They have no markdown mirror, so the post-commit
+// mirror purge below is a no-op for them; they join removedIds for the
+// audit trail and the caller's report.
+function removeDormantCopies(db, tenantId, digest, holdsValue, removal) {
+    const { removedIds, dormantSuccessorIds } = removal;
+    removedIds.push(...purgeDormantByDigest(db, tenantId, digest));
+    for (const dormant of listDormantSnapshots(db, tenantId)) {
+        const successor = mergedSuccessor(dormant.entry, holdsValue, new Set(removedIds));
+        if (successor === undefined)
+            continue;
+        removedIds.push(dormant.entry.id);
+        if (!successor) {
+            deleteDormantRow(db, tenantId, dormant.entry.id);
+            continue;
+        }
+        replaceDormantEntry(db, tenantId, dormant.entry.id, successor);
+        dormantSuccessorIds.push(successor.id);
+    }
+}
+function auditRejectValue(db, opts, digest, removedIds) {
+    try {
+        appendAuditEvent(db, {
+            tenantId: opts.tenantId,
+            actor: opts.actor,
+            op: 'reject_value',
+            targetId: opts.memoryId,
+            metadata: { digest, removedIds, count: removedIds.length },
+        });
+    }
+    catch (error) {
+        // Inside the open transaction: the reject commits without its trail row rather than rolling back over bookkeeping.
+        reportAuditWriteFailure('reject_value', String(error), opts.memoryId);
+    }
+}
+// Post-commit, db handle still open (same pattern as api.archiveRaw):
+// best-effort mirror purge per removed id, reaper-backstop stamp for
+// raw ids.
+function purgeRemovedMirrors(db, hippoRoot, removal) {
+    for (const id of removal.removedIds) {
+        // purgeMirrorBestEffort retries once, then for non-raw ids (which the
+        // reaper never scans) reports the EXPLICIT leftover path(s). See its own doc comment (store.ts, near
+        // removeEntryMirrors) for the full rationale.
+        const mirrorOk = purgeMirrorBestEffort(hippoRoot, id, removal.removedRawIds.includes(id), 'hippo reject');
+        if (mirrorOk && removal.removedRawIds.includes(id)) {
+            db.prepare(`UPDATE raw_archive SET mirror_cleaned_at = ? WHERE memory_id = ?`).run(new Date().toISOString(), id);
         }
+    }
+    for (const successor of removal.successors)
+        writeEntryMirrors(hippoRoot, successor);
+}
+/**
+ * `hippo reject` / `api.reject` core flow. ONE connection, one transaction:
+ * insert the tombstone, enumerate + remove every live tenant row whose
+ * normalized digest matches (kind-aware), one aggregate `reject_value`
+ * audit, COMMIT. Then post-commit (mirrors the existing purge+reaper
+ * pattern verbatim from api.archiveRaw, api.ts:1913-1938): best-effort
+ * mirror purge per removed id, `mirror_cleaned_at` stamps for raw ids.
+ * index.json itself is only refreshed by `rebuildIndex()`.
+ */
+export function rejectValue(opts) {
+    assertRejectOpts(opts);
+    const db = openStore(opts.hippoRoot);
+    try {
+        const content = contentToReject(db, opts);
         const digest = rejectionDigest(content);
         const now = new Date().toISOString();
-        const removedIds = [];
-        const removedRawIds = [];
-        const successors = [];
-        const dormantSuccessorIds = [];
+        const removal = { removedIds: [], removedRawIds: [], successors: [], dormantSuccessorIds: [] };
         db.exec('BEGIN');
         try {
             insertRejectedValue(db, {
@@ -90,69 +172,9 @@ export function rejectValue(opts) {
             // on ~1-5k-row stores — acceptable, documented. A digest column on
             // memories is the escape if stores grow 100x; not needed now.
             const holdsValue = (text) => rejectionDigest(text) === digest;
-            const merged = [];
-            for (const row of selectAllEntries(db, opts.tenantId)) {
-                if (!holdsValue(row.content)) {
-                    if (heldTexts(row).some(holdsValue))
-                        merged.push(row);
-                    continue;
-                }
-                if (row.kind === 'raw') {
-                    // Append-only trigger respected — archiveRawMemory is the only
-                    // legitimate removal path for kind='raw', and its inner SAVEPOINT
-                    // composes safely inside this BEGIN/COMMIT.
-                    archiveRawMemory(db, row.id, { reason: opts.reason, who: opts.actor });
-                    removedRawIds.push(row.id);
-                }
-                else {
-                    // suppressForgetAudit: the aggregate reject_value row below is the
-                    // trail for these removals, not N individual forget rows (plan
-                    // §4, round-3 advisory 2 — mirrors api.ts:1873-1877).
-                    deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
-                }
-                removedIds.push(row.id);
-            }
-            for (const row of merged) {
-                const successor = mergedSuccessor(row, holdsValue, new Set(removedIds));
-                deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
-                removedIds.push(row.id);
-                if (!successor)
-                    continue;
-                const kept = stampOriginProject(opts.hippoRoot, successor);
-                writeEntryDbOnly(db, kept, { actor: opts.actor });
-                successors.push(kept);
-            }
-            // Dormant copies (src/dormant.ts), whole or inside a merged row, go too, in the same transaction: a
-            // rejected value may not linger where `hippo dormant restore` could
-            // bring it back. They have no markdown mirror, so the post-commit
-            // mirror purge below is a no-op for them; they join removedIds for the
-            // audit trail and the caller's report.
-            removedIds.push(...purgeDormantByDigest(db, opts.tenantId, digest));
-            for (const dormant of listDormantSnapshots(db, opts.tenantId)) {
-                const successor = mergedSuccessor(dormant.entry, holdsValue, new Set(removedIds));
-                if (successor === undefined)
-                    continue;
-                removedIds.push(dormant.entry.id);
-                if (!successor) {
-                    deleteDormantRow(db, opts.tenantId, dormant.entry.id);
-                    continue;
-                }
-                replaceDormantEntry(db, opts.tenantId, dormant.entry.id, successor);
-                dormantSuccessorIds.push(successor.id);
-            }
-            try {
-                appendAuditEvent(db, {
-                    tenantId: opts.tenantId,
-                    actor: opts.actor,
-                    op: 'reject_value',
-                    targetId: opts.memoryId,
-                    metadata: { digest, removedIds, count: removedIds.length },
-                });
-            }
-            catch (error) {
-                // Inside the open transaction: the reject commits without its trail row rather than rolling back over bookkeeping.
-                reportAuditWriteFailure('reject_value', String(error), opts.memoryId);
-            }
+            removeLiveRows(db, opts, holdsValue, removal);
+            removeDormantCopies(db, opts.tenantId, digest, holdsValue, removal);
+            auditRejectValue(db, opts, digest, removal.removedIds);
             db.exec('COMMIT');
         }
         catch (err) {
@@ -164,22 +186,8 @@ export function rejectValue(opts) {
             }
             throw err;
         }
-        // Post-commit, db handle still open (same pattern as api.archiveRaw):
-        // best-effort mirror purge per removed id, reaper-backstop stamp for
-        // raw ids.
-        for (const id of removedIds) {
-            // AT1 fix: purgeMirrorBestEffort retries once, then — for non-raw ids,
-            // which cleanupArchivedMirrors' reaper never scans — reports the
-            // EXPLICIT leftover path(s) instead of the false "will retry via
-            // reaper" claim. See its own doc comment (store.ts, near
-            // removeEntryMirrors) for the full rationale.
-            const mirrorOk = purgeMirrorBestEffort(opts.hippoRoot, id, removedRawIds.includes(id), 'hippo reject');
-            if (mirrorOk && removedRawIds.includes(id)) {
-                db.prepare(`UPDATE raw_archive SET mirror_cleaned_at = ? WHERE memory_id = ?`).run(new Date().toISOString(), id);
-            }
-        }
-        for (const successor of successors)
-            writeEntryMirrors(opts.hippoRoot, successor);
+        purgeRemovedMirrors(db, opts.hippoRoot, removal);
+        const { removedIds, removedRawIds, successors, dormantSuccessorIds } = removal;
         return { digest, content, removedIds, removedRawIds, successorIds: successors.map((s) => s.id), dormantSuccessorIds };
     }
     finally {
@@ -192,11 +200,8 @@ export function rejectValue(opts) {
  * (plan §4): no per-write force flag.
  */
 export function unrejectValue(hippoRoot, tenantId, digestOrPrefix, actor) {
-    // P2 fix: an empty/blank prefix startsWith-matches EVERY digest (every
-    // string starts with ''), which would previously fall through to the
-    // ambiguous-candidates branch and list the whole tombstone set instead of
-    // failing loud on the actually-invalid input. Reject before the DB round
-    // trip.
+    // An empty/blank prefix startsWith-matches EVERY digest and would list the whole
+    // tombstone set as ambiguous, so reject it before the DB round trip.
     if (digestOrPrefix.trim().length === 0) {
         return { status: 'not_found' };
     }

package/dist/rejection.d.ts

@@ -1,6 +1,5 @@
 /**
- * AT1 rejected-value tombstone — core invariant.
- * docs/plans/2026-08-15-at1-rejected-value-tombstone.md
+ * Rejected-value tombstone: core invariant.
  *
  * Exact-normalized-value semantics: a human who rejects a fact can refuse
  * byte-stable re-ingestion of the same value across remember/capture/import/
@@ -64,7 +63,7 @@ export interface RejectedValueRow {
 export declare function findRejectedValue(db: DatabaseSyncLike, tenantId: string, digest: string): RejectedValueRow | null;
 /**
  * Insert (or refresh) a tombstone row. Caller owns the transaction — used by
- * the T2 `reject` verb and `resolveConflict`'s `rejectLoserValue` path.
+ * the `reject` verb and `resolveConflict`'s `rejectLoserValue` path.
  */
 export declare function insertRejectedValue(db: DatabaseSyncLike, opts: {
     tenantId: string;
@@ -76,11 +75,11 @@ export declare function insertRejectedValue(db: DatabaseSyncLike, opts: {
     normalizedChars: number;
 }): void;
 /**
- * Delete a tombstone by tenant + exact digest — the T2 `unreject` verb, the
- * only v1 escape hatch (plan §4).
+ * Delete a tombstone by tenant + exact digest: the `unreject` verb, the
+ * only escape hatch.
  */
 export declare function deleteRejectedValue(db: DatabaseSyncLike, tenantId: string, digest: string): boolean;
-/** List tombstones for a tenant, newest first — the T2 `rejections` verb. */
+/** List tombstones for a tenant, newest first: the `rejections` verb. */
 export declare function listRejectedValues(db: DatabaseSyncLike, tenantId: string): RejectedValueRow[];
 /**
  * The write-path guard's check helper, called from `upsertEntryRow`

package/dist/rejection.js

@@ -1,6 +1,5 @@
 /**
- * AT1 rejected-value tombstone — core invariant.
- * docs/plans/2026-08-15-at1-rejected-value-tombstone.md
+ * Rejected-value tombstone: core invariant.
  *
  * Exact-normalized-value semantics: a human who rejects a fact can refuse
  * byte-stable re-ingestion of the same value across remember/capture/import/
@@ -80,7 +79,7 @@ export function findRejectedValue(db, tenantId, digest) {
 }
 /**
  * Insert (or refresh) a tombstone row. Caller owns the transaction — used by
- * the T2 `reject` verb and `resolveConflict`'s `rejectLoserValue` path.
+ * the `reject` verb and `resolveConflict`'s `rejectLoserValue` path.
  */
 export function insertRejectedValue(db, opts) {
     db.prepare(`INSERT INTO rejected_values(tenant_id, digest, reason, rejected_by, rejected_at, source_memory_id, normalized_chars)
@@ -93,14 +92,14 @@ export function insertRejectedValue(db, opts) {
        normalized_chars = excluded.normalized_chars`).run(opts.tenantId, opts.digest, opts.reason, opts.rejectedBy, opts.rejectedAt, opts.sourceMemoryId ?? null, opts.normalizedChars);
 }
 /**
- * Delete a tombstone by tenant + exact digest — the T2 `unreject` verb, the
- * only v1 escape hatch (plan §4).
+ * Delete a tombstone by tenant + exact digest: the `unreject` verb, the
+ * only escape hatch.
  */
 export function deleteRejectedValue(db, tenantId, digest) {
     const result = db.prepare(`DELETE FROM rejected_values WHERE tenant_id = ? AND digest = ?`).run(tenantId, digest);
     return (result.changes ?? 0) > 0;
 }
-/** List tombstones for a tenant, newest first — the T2 `rejections` verb. */
+/** List tombstones for a tenant, newest first: the `rejections` verb. */
 export function listRejectedValues(db, tenantId) {
     // SAFETY: rows' shape matches the columns named in the SELECT above.
     const rows = db
@@ -134,15 +133,8 @@ export function checkRejectionGuard(db, tenantId, entryId, content) {
     // id the caller is already writing, and the tombstone lookup above is the
     // tenant-scoped decision. Matches deleteEntry's own by-id SELECT.
     //
-    // P2 fix: also read tenant_id. Content-digest-only comparison let a
-    // same-id upsert that ONLY changes tenantId slip through as an "unchanged
-    // re-persist" — content C sitting quietly (never rejected) in tenant A
-    // could be re-tagged into tenant B, and since C's digest already matched
-    // this row's stored digest, the guard exempted it even though B is the
-    // tenant that rejected C (that is WHY `tombstone` above is non-null: the
-    // lookup already ran under the INCOMING/destination tenantId). A tenant
-    // change on the SAME id is therefore always a content introduction into
-    // the destination tenant, exactly as if the row were new there.
+    // Also read tenant_id: a same-id upsert that only changes tenantId introduces the
+    // content into the destination tenant, exactly as if the row were new there.
     // SAFETY: storedRow's shape matches the two columns named in the SELECT above.
     const storedRow = db.prepare(`SELECT content, tenant_id FROM memories WHERE id = ?`).get(entryId);
     const isNewRow = storedRow === undefined;

package/dist/rerankers/clef.d.ts

@@ -1,5 +1,5 @@
 import type { RerankerFn, RerankProvenance } from './types.js';
-import { type JsonValue } from '../http-util.js';
+import type { JsonValue } from '../json.js';
 /** The two pretrained CLEF decision models served by Cloudflare Workers AI. */
 export type ClefModel = 'clef-flash' | 'clef';
 /** True when `name` is one of the CLEF reranker names. */

package/dist/rerankers/jev.d.ts

@@ -16,7 +16,6 @@ export declare function createJevReranker(localFallback: RerankerFn): RerankerFn
 /** Orders `head` by `scores[i]`, keeping any upstream pre-rerank rank. Shared with CLEF. */
 export declare function rankByScores(head: readonly SearchResult[], scores: readonly number[]): RerankResult[];
 /** Track 4 reranker: hosted TypeSafe Jev, opt-in and paid (TYPESAFE_API_KEY), one batched call per recall.
- *  Any failure warns once and delegates to the local cross-encoder. Scores are not bit-stable run to run.
- *  Cost, env vars, evidence and limits: docs/evals/2026-09-19-jev-reranker.md. */
+ *  Any failure warns once and delegates to the local cross-encoder. Scores are not bit-stable run to run. */
 export declare const jevReranker: RerankerFn;
 //# sourceMappingURL=jev.d.ts.map

package/dist/rerankers/jev.js

@@ -5,10 +5,10 @@ import { log } from '../log.js';
 const ENDPOINT = 'https://api.typesafe.ai/v1/systemone';
 const DEFAULT_TIMEOUT_MS = 5_000;
 const TRUNCATE_CHARS = 1200;
-// Pinned, not `jev-latest`: every number in docs/evals/2026-09-19-jev-reranker.md was
-// measured on this version, and the alias moves whenever the vendor ships a release.
+// Pinned, not `jev-latest`: the eval numbers were measured on this version,
+// and the alias moves whenever the vendor ships a release.
 const DEFAULT_MODEL = 'jev-1.13.0';
-// The pool size every number in docs/evals/2026-09-19-jev-reranker.md was measured at.
+// The pool size the eval numbers were measured at.
 export const JEV_DEFAULT_TOP_K = 40;
 function truncate(s, n) {
     return s.length <= n ? s : `${s.slice(0, n)}...`;
@@ -124,7 +124,6 @@ export function rankByScores(head, scores) {
     return scored;
 }
 /** Track 4 reranker: hosted TypeSafe Jev, opt-in and paid (TYPESAFE_API_KEY), one batched call per recall.
- *  Any failure warns once and delegates to the local cross-encoder. Scores are not bit-stable run to run.
- *  Cost, env vars, evidence and limits: docs/evals/2026-09-19-jev-reranker.md. */
+ *  Any failure warns once and delegates to the local cross-encoder. Scores are not bit-stable run to run. */
 export const jevReranker = createJevReranker(crossEncoderReranker);
 //# sourceMappingURL=jev.js.map

package/dist/rerankers/llm.d.ts

@@ -4,8 +4,7 @@ import type { RerankerFn } from './types.js';
  * OpenAI-compatible endpoint. Gated on HIPPO_LLM_RERANKER_URL to prevent
  * accidental cost.
  *
- * Skeleton only — see docs/plans/2026-05-10-f6-reranker-hardening.md Task 8.
- * Full characterisation deferred to a follow-on plan.
+ * Skeleton only; full characterisation is deferred.
  *
  * Timeout: defaults to 30s; overridable via HIPPO_LLM_RERANKER_TIMEOUT_MS.
  * On timeout or any fetch failure, the reranker warns once per process and

package/dist/rerankers/llm.js

@@ -7,8 +7,7 @@ const DEFAULT_TIMEOUT_MS = 30_000;
  * OpenAI-compatible endpoint. Gated on HIPPO_LLM_RERANKER_URL to prevent
  * accidental cost.
  *
- * Skeleton only — see docs/plans/2026-05-10-f6-reranker-hardening.md Task 8.
- * Full characterisation deferred to a follow-on plan.
+ * Skeleton only; full characterisation is deferred.
  *
  * Timeout: defaults to 30s; overridable via HIPPO_LLM_RERANKER_TIMEOUT_MS.
  * On timeout or any fetch failure, the reranker warns once per process and

package/dist/rerankers/types.d.ts

@@ -9,8 +9,7 @@ import type { SearchResult } from '../search/types.js';
  * Rerankers MUST be deterministic for a given (query, results) input
  * unless explicitly documented as stochastic (the LLM track, and the
  * hosted jev reranker, whose scores move slightly run to run).
- * Determinism is required for paired A/B and for the workload-validity
- * gate in docs/evals/2026-05-10-f6-reranker-prereg.md.
+ * Determinism is required for paired A/B and for the workload-validity gate.
  *
  * @returns Reordered (and optionally rescaled) results.
  */