hippo-memory 1.61.0 → 1.63.0

package/dist/goals.js

@@ -29,7 +29,7 @@ export function pushGoal(hippoRoot, opts) {
     }
 }
 /**
- * v1.7.4 — depth-cap enforcer extracted from pushGoalWithDb and resumeGoal.
+ * Depth-cap enforcer shared by pushGoalWithDb and resumeGoal.
  * If the (tenant, session) has >= MAX_ACTIVE_GOAL_DEPTH active goals,
  * suspend the oldest `overflow` ones.
  *
@@ -38,7 +38,7 @@ export function pushGoal(hippoRoot, opts) {
  * is impossible to misread the contract at a call site. Both existing call
  * sites (pushGoalWithDb, resumeGoal) wrap in `BEGIN IMMEDIATE` already.
  *
- * @internal v1.7.4 -- internal goal-stack invariant. Subject to change.
+ * @internal Internal goal-stack invariant. Subject to change.
  */
 export function enforceDepthCapWithinTx(db, tenantId, sessionId) {
     // SAFETY: the row comes from the SELECT above, which projects exactly one
@@ -159,35 +159,11 @@ export function getActiveGoalsWithDb(db, opts) {
   `).all(opts.tenantId, opts.sessionId);
     return rows.map(rowToGoal);
 }
-/**
- * dlPFC goal-stack boost. Applies the multi-goal boost to entry-backed scored
- * rows when (tenant, session) has active goals and returns the log rows to
- * write, without writing them; {@link writeGoalRecallLog} persists them.
- *
- * Caller responsibilities:
- *   - Do NOT call when an explicit `goalTag` is set (caller's gate)
- *   - Pass entry-backed rows (with `entry.tags`, `entry.id`, optional
- *     `entry.schema_fit`)
- *   - Manage the db handle lifecycle (helper neither opens nor closes)
- *   - Recompute `tokens` after if returned rows are projected to a budgeted
- *     shape
- *
- * Log rows cover the top `limit` boosted rows that live in this store's
- * `memories` table (global-only ids are skipped to keep the FK on
- * goal_recall_log.memory_id valid).
- *
- * @internal Recall ranking helper. Subject to change.
- */
-export function computeGoalStackBoost(db, results, opts) {
-    const { sessionId, tenantId, limit, trace } = opts;
-    const active = getActiveGoalsWithDb(db, { sessionId, tenantId });
-    if (active.length === 0)
-        return { results, log: [] };
-    const goalsByTag = new Map(active.map((g) => [g.goalName, g]));
-    // Load retrieval_policy rows for active goals so per-policy multipliers
-    // can compose onto the base goal-tag boost. Composed result is hard-capped
-    // at MAX_FINAL_MULTIPLIER (3.0x) BEFORE applying to score -- even an
-    // `errorPriority: 9.0` policy cannot exceed 3.0x.
+// Load retrieval_policy rows for active goals so per-policy multipliers
+// can compose onto the base goal-tag boost. Composed result is hard-capped
+// at MAX_FINAL_MULTIPLIER (3.0x) BEFORE applying to score -- even an
+// `errorPriority: 9.0` policy cannot exceed 3.0x.
+function loadGoalPolicies(db, active) {
     const policiesByGoalId = new Map();
     for (const g of active) {
         if (!g.retrievalPolicyId)
@@ -210,67 +186,42 @@ export function computeGoalStackBoost(db, results, opts) {
             });
         }
     }
-    // Goal-tag matches per boosted row, keyed by entry id. Kept as a side table
-    // (rather than a spread-on `_goalMatches` marker property) so `boosted`
-    // stays exactly R[] end to end, with no cast-tag-then-strip round trip.
-    const matchesByEntryId = new Map();
-    const boosted = results
-        .map((r) => {
-        const tags = r.entry.tags ?? [];
-        const matches = tags.filter((t) => goalsByTag.has(t));
-        if (matches.length === 0)
-            return r;
-        // Base 2.0x for first match, +0.5x per additional, capped at 3.0x.
-        let multiplier = Math.min(2.0 + 0.5 * (matches.length - 1), MAX_FINAL_MULTIPLIER);
-        // Compose per-policy multipliers per matched tag.
-        for (const tag of matches) {
-            const goal = goalsByTag.get(tag);
-            const policy = policiesByGoalId.get(goal.id);
-            if (!policy)
-                continue;
-            if (policy.policyType === 'error-prioritized' && tags.includes('error')) {
-                multiplier *= policy.errorPriority;
-            }
-            else if (policy.policyType === 'schema-fit-biased') {
-                // Linearly weight schema_fit in [0,1] up to (weightSchemaFit)x.
-                // Default 1.0 is a no-op.
-                multiplier *=
-                    1.0 +
-                        Math.max(0, policy.weightSchemaFit - 1.0) *
-                            (r.entry.schema_fit ?? 0.5);
-            }
-            else if (policy.policyType === 'recency-first') {
-                multiplier *= policy.weightRecency;
-            }
-            else if (policy.policyType === 'hybrid') {
-                multiplier *= policy.weightOutcome;
-            }
+    return policiesByGoalId;
+}
+/** The capped boost for one row whose tags match `matches` active goals. */
+function goalBoostMultiplier(entry, tags, matches, goalsByTag, policiesByGoalId) {
+    // Base 2.0x for first match, +0.5x per additional, capped at 3.0x.
+    let multiplier = Math.min(2.0 + 0.5 * (matches.length - 1), MAX_FINAL_MULTIPLIER);
+    // Compose per-policy multipliers per matched tag.
+    for (const tag of matches) {
+        const goal = goalsByTag.get(tag);
+        const policy = policiesByGoalId.get(goal.id);
+        if (!policy)
+            continue;
+        if (policy.policyType === 'error-prioritized' && tags.includes('error')) {
+            multiplier *= policy.errorPriority;
         }
-        // Hard cap AFTER all composition.
-        multiplier = Math.min(multiplier, MAX_FINAL_MULTIPLIER);
-        // A7 recall-trace side-channel: record the goal-boost step BEFORE the
-        // score is mutated, keyed by entry id. Pure read of r.score here; the
-        // mutation below is byte-identical to pre-A7.
-        if (trace) {
-            trace.set(r.entry.id, {
-                stage: 'goal-boost',
-                multiplier,
-                scoreBefore: r.score,
-                scoreAfter: r.score * multiplier,
-                note: matches.join(', '),
-            });
+        else if (policy.policyType === 'schema-fit-biased') {
+            // Linearly weight schema_fit in [0,1] up to (weightSchemaFit)x.
+            // Default 1.0 is a no-op.
+            multiplier *=
+                1.0 +
+                    Math.max(0, policy.weightSchemaFit - 1.0) *
+                        (entry.schema_fit ?? 0.5);
         }
-        matchesByEntryId.set(r.entry.id, matches);
-        // SAFETY: spreading a generic-constrained `r: R` widens the result to
-        // the spread's plain object type; only `score` changes, so the value
-        // still satisfies R's shape exactly.
-        return { ...r, score: r.score * multiplier };
-    })
-        // T2 note: deliberately a PLAIN stable score sort, no compareEntryIdentity
-        // tail -- a re-sort of an already deterministically-ordered ranking
-        // inherits its determinism via sort stability, and ties preserve the
-        // prior (meaningful) rank instead of reordering by content.
-        .sort((a, b) => b.score - a.score);
+        else if (policy.policyType === 'recency-first') {
+            multiplier *= policy.weightRecency;
+        }
+        else if (policy.policyType === 'hybrid') {
+            multiplier *= policy.weightOutcome;
+        }
+    }
+    // Hard cap AFTER all composition.
+    return Math.min(multiplier, MAX_FINAL_MULTIPLIER);
+}
+/** Log rows for the top `limit` boosted rows, one per matched goal. */
+function buildGoalRecallLog(db, boosted, matchesByEntryId, goalsByTag, opts) {
+    const { sessionId, tenantId, limit } = opts;
     // Filter to local memories only -- global memory IDs aren't in this DB's
     // memories table, so the FK on goal_recall_log.memory_id would fail.
     // dlPFC depth's outcome propagation is session-scoped to local; boost on
@@ -301,7 +252,68 @@ export function computeGoalStackBoost(db, results, opts) {
             log.push({ goalId: goal.id, memoryId: r.entry.id, tenantId, sessionId, recalledAt, score: r.score });
         }
     }
-    return { results: boosted, log };
+    return log;
+}
+/**
+ * dlPFC goal-stack boost. Applies the multi-goal boost to entry-backed scored
+ * rows when (tenant, session) has active goals and returns the log rows to
+ * write, without writing them; {@link writeGoalRecallLog} persists them.
+ *
+ * Caller responsibilities:
+ *   - Do NOT call when an explicit `goalTag` is set (caller's gate)
+ *   - Pass entry-backed rows (with `entry.tags`, `entry.id`, optional
+ *     `entry.schema_fit`)
+ *   - Manage the db handle lifecycle (helper neither opens nor closes)
+ *   - Recompute `tokens` after if returned rows are projected to a budgeted
+ *     shape
+ *
+ * Log rows cover the top `limit` boosted rows that live in this store's
+ * `memories` table (global-only ids are skipped to keep the FK on
+ * goal_recall_log.memory_id valid).
+ *
+ * @internal Recall ranking helper. Subject to change.
+ */
+export function computeGoalStackBoost(db, results, opts) {
+    const { sessionId, tenantId, trace } = opts;
+    const active = getActiveGoalsWithDb(db, { sessionId, tenantId });
+    if (active.length === 0)
+        return { results, log: [] };
+    const goalsByTag = new Map(active.map((g) => [g.goalName, g]));
+    const policiesByGoalId = loadGoalPolicies(db, active);
+    // Goal-tag matches per boosted row, keyed by entry id. Kept as a side table
+    // (rather than a spread-on `_goalMatches` marker property) so `boosted`
+    // stays exactly R[] end to end, with no cast-tag-then-strip round trip.
+    const matchesByEntryId = new Map();
+    const boosted = results
+        .map((r) => {
+        const tags = r.entry.tags ?? [];
+        const matches = tags.filter((t) => goalsByTag.has(t));
+        if (matches.length === 0)
+            return r;
+        const multiplier = goalBoostMultiplier(r.entry, tags, matches, goalsByTag, policiesByGoalId);
+        // Recall-trace side-channel: record the goal-boost step BEFORE the
+        // score is mutated, keyed by entry id; a pure read of r.score.
+        if (trace) {
+            trace.set(r.entry.id, {
+                stage: 'goal-boost',
+                multiplier,
+                scoreBefore: r.score,
+                scoreAfter: r.score * multiplier,
+                note: matches.join(', '),
+            });
+        }
+        matchesByEntryId.set(r.entry.id, matches);
+        // SAFETY: spreading a generic-constrained `r: R` widens the result to
+        // the spread's plain object type; only `score` changes, so the value
+        // still satisfies R's shape exactly.
+        return { ...r, score: r.score * multiplier };
+    })
+        // Deliberately a PLAIN stable score sort, no compareEntryIdentity
+        // tail -- a re-sort of an already deterministically-ordered ranking
+        // inherits its determinism via sort stability, and ties preserve the
+        // prior (meaningful) rank instead of reordering by content.
+        .sort((a, b) => b.score - a.score);
+    return { results: boosted, log: buildGoalRecallLog(db, boosted, matchesByEntryId, goalsByTag, opts) };
 }
 /**
  * Writes goal-boost log rows. INSERT OR IGNORE because UNIQUE(memory_id, goal_id)

package/dist/graph/read.d.ts

@@ -16,7 +16,7 @@ export declare function loadRelations(hippoRoot: string, tenantId: string, opts?
     limit?: number;
 }, txDb?: GraphTxDb): Relation[];
 /**
- * Map consolidated source memory ids -> their graph entities. The SEED step of E3.2
+ * Map consolidated source memory ids -> their graph entities. The SEED step of
  * multi-hop recall (recall result memory ids -> entities to traverse from). Tenant-
  * scoped, read-only; chunks the IN-list under the SQLite variable cap.
  */
@@ -28,7 +28,7 @@ export declare function loadEntitiesByMemoryId(hippoRoot: string, tenantId: stri
 export declare function loadEntitiesByIds(hippoRoot: string, tenantId: string, ids: number[], txDb?: GraphTxDb): Entity[];
 /**
  * All relations touching ANY of `entityIds` in EITHER direction (from OR to) — the
- * per-hop neighbour query for E3.2 multi-hop traversal. ONE query for the whole frontier
+ * per-hop neighbour query for multi-hop traversal. ONE query for the whole frontier
  * (not one per node): this is the bidirectional read `loadRelations` (from-only) lacks,
  * and avoids an N+1 across BFS frontier nodes. `limit` caps rows for the frontier and
  * must be a non-negative integer (the raw `LIMIT ?` rejects a fractional value).

package/dist/graph/read.js

@@ -98,14 +98,14 @@ export function loadRelations(hippoRoot, tenantId, opts = {}, txDb) {
     }
 }
 // ---------------------------------------------------------------------------
-// E3.2 multi-hop recall read helpers (SELECT-only; the check-graph-writes lint
+// Multi-hop recall read helpers (SELECT-only; the check-graph-writes lint
 // permits these here and in the read-only consumer src/graph-recall.ts).
 // ---------------------------------------------------------------------------
 /** Chunk size for IN-list queries: well under SQLite's 999-bound-variable default
  *  (leaves headroom for the tenant_id param + the doubled list in neighbour lookups). */
 const IN_LIST_CHUNK = 400;
 /**
- * Map consolidated source memory ids -> their graph entities. The SEED step of E3.2
+ * Map consolidated source memory ids -> their graph entities. The SEED step of
  * multi-hop recall (recall result memory ids -> entities to traverse from). Tenant-
  * scoped, read-only; chunks the IN-list under the SQLite variable cap.
  */
@@ -119,8 +119,7 @@ export function loadEntitiesByMemoryId(hippoRoot, tenantId, memoryIds) {
         for (let i = 0; i < memoryIds.length; i += IN_LIST_CHUNK) {
             const slice = memoryIds.slice(i, i + IN_LIST_CHUNK);
             const ph = slice.map(() => '?').join(',');
-            // T2: no ORDER BY meant chunk-local scan order decided ties; id ASC
-            // makes it deterministic (entities.id is an autoincrement integer PK).
+            // id ASC so chunk-local scan order never decides ties (id is an autoincrement PK).
             // SAFETY: rows' shape matches the columns named in ENTITY_COLS above.
             const rows = db.prepare(`
         SELECT ${ENTITY_COLS} FROM entities
@@ -166,7 +165,7 @@ export function loadEntitiesByIds(hippoRoot, tenantId, ids, txDb) {
 }
 /**
  * All relations touching ANY of `entityIds` in EITHER direction (from OR to) — the
- * per-hop neighbour query for E3.2 multi-hop traversal. ONE query for the whole frontier
+ * per-hop neighbour query for multi-hop traversal. ONE query for the whole frontier
  * (not one per node): this is the bidirectional read `loadRelations` (from-only) lacks,
  * and avoids an N+1 across BFS frontier nodes. `limit` caps rows for the frontier and
  * must be a non-negative integer (the raw `LIMIT ?` rejects a fractional value).
@@ -183,7 +182,7 @@ export function loadNeighborRelations(hippoRoot, tenantId, entityIds, opts = {},
     const db = txDb ?? ownDb;
     try {
         // `limit` is applied PER CHUNK; a frontier spanning >IN_LIST_CHUNK ids could return
-        // up to limit*chunks rows before the by-id dedup below. Harmless for E3.2 (the
+        // up to limit*chunks rows before the by-id dedup below. Harmless for multi-hop recall (the
         // frontier is bounded by maxNeighbors <= 200 << IN_LIST_CHUNK, so a single chunk,
         // and the BFS re-enforces the per-hop fanout cap), but note the semantics if a
         // tighter total cap is ever needed.

package/dist/graph/types.d.ts

@@ -8,10 +8,10 @@ export type RelationType = 'owns' | 'supersedes' | 'depends-on' | 'blocked-by' |
 export type GraphQueueStatus = 'pending' | 'processed' | 'skipped';
 /** The consolidated source kinds the graph is permitted to index (never 'raw'). */
 export type SourceKind = 'distilled' | 'superseded';
-/** The authoritative E2 object types a graph row may be anchored to (the object
+/** The authoritative first-class object types a graph row may be anchored to (the object
  *  provenance path, alongside the memory path). Maps to source_object_type. */
 export type SourceObjectType = 'decision' | 'policy' | 'customer' | 'project';
-/** A soft (type,id) pointer to the authoritative E2 row a graph row descends from.
+/** A soft (type,id) pointer to the authoritative object row a graph row descends from.
  *  Survives a mirror memory forget/prune (memory_id may go NULL); the rebuild
  *  re-validates it (it is not a hard FK). */
 export interface SourceObjectRef {
@@ -32,8 +32,8 @@ export interface Entity {
      *  its source_object provenance. */
     memoryId: string | null;
     sourceKind: SourceKind;
-    /** The authoritative E2 object this entity is anchored to (E2-provenance path).
-     *  Set for E2-sourced entities; absent for memory-only (prose/NLP) entities. */
+    /** The authoritative object this entity is anchored to (object-provenance path).
+     *  Set for object-sourced entities; absent for memory-only (prose/NLP) entities. */
     sourceObjectType?: SourceObjectType;
     sourceObjectId?: number;
     createdAt: string;
@@ -64,9 +64,9 @@ export interface InsertEntityOpts {
     entityType: EntityType;
     name: string;
     /** A consolidated (distilled/superseded) memory; raw is rejected. NULL/omitted when
-     *  the entity is anchored only to its E2 source object (mirror forgotten/pruned). */
+     *  the entity is anchored only to its source object (mirror forgotten/pruned). */
     memoryId?: string | null;
-    /** The authoritative E2 object this entity descends from. Required when memoryId is
+    /** The authoritative object this entity descends from. Required when memoryId is
      *  null; optional alongside a live memory (both paths may be set). */
     sourceObject?: SourceObjectRef;
 }
@@ -75,9 +75,9 @@ export interface InsertRelationOpts {
     toEntityId: number;
     relType: RelationType;
     /** A consolidated (distilled/superseded) memory; raw is rejected. NULL/omitted when
-     *  the relation is anchored only to its E2 source object. */
+     *  the relation is anchored only to its source object. */
     memoryId?: string | null;
-    /** The authoritative E2 object this relation descends from. */
+    /** The authoritative object this relation descends from. */
     sourceObject?: SourceObjectRef;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/graph/write.d.ts

@@ -1,6 +1,5 @@
 /**
- * E3.3 graph layer over consolidated state - the graph-on-consolidated guard.
- * (docs/plans/2026-06-01-e3-graph-guard.md).
+ * Graph layer over consolidated state - the graph-on-consolidated guard.
  *
  * A graph of canonical `entities` (person/project/customer/system/policy/decision) and
  * `relations` (owns/supersedes/depends-on/blocked-by/references) sits ON TOP OF
@@ -11,11 +10,6 @@
  * actual kind and enforce tenant-match - relations also reject cross-tenant edges), so
  * the forbidden state is unrepresentable regardless of code path. These helpers
  * surface the same guard as clear throws BEFORE hitting the trigger backstop.
- *
- * Scope (E3.3 first slice): the substrate + the guard + a thin insert/load/enqueue
- * API. The `graph_extraction_queue` is the interface the deferred `hippo sleep`
- * enqueue-hook + E3.1 entity extraction will call. No operator surface (CLI/HTTP/SDK)
- * until E3.2 multi-hop recall.
  */
 import { type GraphTxDb, type SourceObjectType, type Entity, type Relation, type GraphQueueItem, type InsertEntityOpts, type InsertRelationOpts } from './types.js';
 /**
@@ -30,8 +24,7 @@ export declare function insertEntity(hippoRoot: string, tenantId: string, opts:
 export declare function insertRelation(hippoRoot: string, tenantId: string, opts: InsertRelationOpts, txDb?: GraphTxDb): Relation;
 /**
  * Enqueue a consolidated memory for later graph extraction. Rejects a raw / missing /
- * cross-tenant memory (the DB trigger is the backstop). The producer hook in
- * `hippo sleep` is deferred (E3.1); this is the API it will call.
+ * cross-tenant memory (the DB trigger is the backstop).
  */
 export declare function enqueueExtraction(hippoRoot: string, tenantId: string, memoryId: string): GraphQueueItem;
 /**
@@ -46,7 +39,7 @@ export declare function markExtractionProcessed(hippoRoot: string, tenantId: str
  * the number of entities deleted. The rebuild primitive for graph extraction: the
  * deterministic graph is a pure derived function of the consolidated objects, so an
  * extract clears then re-derives. Lives in graph.ts (the sole sanctioned graph
- * writer), so the E3.3 CI lint permits this `DELETE FROM entities`. Does NOT touch
+ * writer), so the CI lint permits this `DELETE FROM entities`. Does NOT touch
  * graph_extraction_queue (the enqueue-hook's domain).
  */
 export declare function clearGraph(hippoRoot: string, tenantId: string, txDb?: GraphTxDb): number;
@@ -63,19 +56,19 @@ export declare function runGraphRebuildTransaction<T>(hippoRoot: string, tenantI
 /**
  * Fail-soft producer hook: mark a tenant dirty for graph re-extraction by
  * enqueuing its consolidated mirror memory. NEVER throws into the caller — a
- * graph-dirty signal failing must not abort a core E2 write. Graph staleness is
+ * graph-dirty signal failing must not abort a core object write. Graph staleness is
  * recoverable (next sleep / manual `graph extract`); a broken `hippo decide` is
- * not. Called POST-COMMIT from the E2 graph-source save/close mutations of
+ * not. Called POST-COMMIT from the graph-source save/close mutations of
  * decision, policy, customer_note and project_brief. A null memoryId (a
  * forgotten mirror) is a no-op.
  */
 export declare function markGraphDirty(hippoRoot: string, tenantId: string, memoryId: string | null): void;
 /**
- * Remove the graph rows sourced from one E2 object, by its (type, id). Used when a
+ * Remove the graph rows sourced from one first-class object, by its (type, id). Used when a
  * MIRRORLESS object is closed: it has no mirror memory, so `markGraphDirty` cannot
  * enqueue a rebuild (the queue is memory-keyed). Closing must still drop the object's
  * now-stale entity + edges from the graph, so we remove them directly here. Fail-soft
- * like `markGraphDirty` (never throws into the E2 close caller; graph staleness is
+ * like `markGraphDirty` (never throws into the object close caller; graph staleness is
  * recoverable). Deleting the entity cascade-deletes any relation where it is an endpoint
  * (relations FK entities ON DELETE CASCADE); the explicit relations DELETE also covers a
  * relation whose OWN provenance is this object (defensive — every such edge has the object

package/dist/graph/write.js

@@ -1,6 +1,5 @@
 /**
- * E3.3 graph layer over consolidated state - the graph-on-consolidated guard.
- * (docs/plans/2026-06-01-e3-graph-guard.md).
+ * Graph layer over consolidated state - the graph-on-consolidated guard.
  *
  * A graph of canonical `entities` (person/project/customer/system/policy/decision) and
  * `relations` (owns/supersedes/depends-on/blocked-by/references) sits ON TOP OF
@@ -11,11 +10,6 @@
  * actual kind and enforce tenant-match - relations also reject cross-tenant edges), so
  * the forbidden state is unrepresentable regardless of code path. These helpers
  * surface the same guard as clear throws BEFORE hitting the trigger backstop.
- *
- * Scope (E3.3 first slice): the substrate + the guard + a thin insert/load/enqueue
- * API. The `graph_extraction_queue` is the interface the deferred `hippo sleep`
- * enqueue-hook + E3.1 entity extraction will call. No operator surface (CLI/HTTP/SDK)
- * until E3.2 multi-hop recall.
  */
 import { openHippoDb, closeHippoDb } from '../db.js';
 import { assertTenantId } from '../tenant.js';
@@ -37,9 +31,9 @@ function resolveConsolidatedSource(db, tenantId, memoryId, sourceObject, label)
         const row = db.prepare(`SELECT kind, tenant_id FROM memories WHERE id = ?`).get(memoryId);
         if (!row) {
             // Stale / forgotten mirror. Tolerate it IFF a valid source object provides provenance:
-            // graph-extract reads E2 rows then inserts, and a mirror forgotten/pruned in that window
-            // must NOT roll back the whole tenant rebuild - the active E2 object survives mirror loss
-            // (v38 contract; codex round-4 race). Anchor to the object; drop the dead memory pointer.
+            // graph-extract reads object rows then inserts, and a mirror forgotten/pruned in that window
+            // must NOT roll back the whole tenant rebuild - the active object survives mirror loss.
+            // Anchor to the object; drop the dead memory pointer.
             if (sourceObject == null) {
                 throw new Error(`${label}: source memory ${memoryId} not found`);
             }
@@ -58,8 +52,8 @@ function resolveConsolidatedSource(db, tenantId, memoryId, sourceObject, label)
             memKind = row.kind;
         }
     }
-    // Validate the object pointer WHENEVER it is provided - not only when memory is null
-    // (codex review): a dual-set row whose object is wrong/closed/cross-tenant would become
+    // Validate the object pointer WHENEVER it is provided, not only when memory is null:
+    // a dual-set row whose object is wrong/closed/cross-tenant would become
     // the active provenance after ON DELETE SET NULL and could then block the memory delete.
     if (sourceObject != null) {
         const table = SOURCE_OBJECT_TABLE[sourceObject.type];
@@ -79,7 +73,7 @@ function resolveConsolidatedSource(db, tenantId, memoryId, sourceObject, label)
         }
     }
     // source_kind is the memory's kind when a memory is present, else 'distilled' for an
-    // object-only row (E2 objects are consolidated by construction). All-null is rejected.
+    // object-only row (objects are consolidated by construction). All-null is rejected.
     if (memKind != null)
         return { sourceKind: memKind, memoryId: effectiveMemoryId };
     if (sourceObject != null)
@@ -170,12 +164,11 @@ export function insertRelation(hippoRoot, tenantId, opts, txDb) {
     }
 }
 // ---------------------------------------------------------------------------
-// Extraction queue (the interface the deferred sleep enqueue-hook + E3.1 will use)
+// Extraction queue
 // ---------------------------------------------------------------------------
 /**
  * Enqueue a consolidated memory for later graph extraction. Rejects a raw / missing /
- * cross-tenant memory (the DB trigger is the backstop). The producer hook in
- * `hippo sleep` is deferred (E3.1); this is the API it will call.
+ * cross-tenant memory (the DB trigger is the backstop).
  */
 export function enqueueExtraction(hippoRoot, tenantId, memoryId) {
     assertTenantId('enqueueExtraction', tenantId);
@@ -241,7 +234,7 @@ export function markExtractionProcessed(hippoRoot, tenantId, id, status = 'proce
  * the number of entities deleted. The rebuild primitive for graph extraction: the
  * deterministic graph is a pure derived function of the consolidated objects, so an
  * extract clears then re-derives. Lives in graph.ts (the sole sanctioned graph
- * writer), so the E3.3 CI lint permits this `DELETE FROM entities`. Does NOT touch
+ * writer), so the CI lint permits this `DELETE FROM entities`. Does NOT touch
  * graph_extraction_queue (the enqueue-hook's domain).
  */
 export function clearGraph(hippoRoot, tenantId, txDb) {
@@ -292,14 +285,14 @@ export function runGraphRebuildTransaction(hippoRoot, tenantId, fn) {
     }
 }
 // ---------------------------------------------------------------------------
-// E3 sleep enqueue-hook — producer helper + drain support
+// Sleep enqueue-hook: producer helper + drain support
 // ---------------------------------------------------------------------------
 /**
  * Fail-soft producer hook: mark a tenant dirty for graph re-extraction by
  * enqueuing its consolidated mirror memory. NEVER throws into the caller — a
- * graph-dirty signal failing must not abort a core E2 write. Graph staleness is
+ * graph-dirty signal failing must not abort a core object write. Graph staleness is
  * recoverable (next sleep / manual `graph extract`); a broken `hippo decide` is
- * not. Called POST-COMMIT from the E2 graph-source save/close mutations of
+ * not. Called POST-COMMIT from the graph-source save/close mutations of
  * decision, policy, customer_note and project_brief. A null memoryId (a
  * forgotten mirror) is a no-op.
  */
@@ -311,16 +304,16 @@ export function markGraphDirty(hippoRoot, tenantId, memoryId) {
     }
     catch (err) {
         // Logged (warn) so a SYSTEMATIC enqueue failure surfaces to operators, but
-        // swallowed so the already-committed E2 write is never rolled back.
+        // swallowed so the already-committed object write is never rolled back.
         log.warn(`markGraphDirty: enqueue failed for tenant=${tenantId} memory=${memoryId}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /**
- * Remove the graph rows sourced from one E2 object, by its (type, id). Used when a
+ * Remove the graph rows sourced from one first-class object, by its (type, id). Used when a
  * MIRRORLESS object is closed: it has no mirror memory, so `markGraphDirty` cannot
  * enqueue a rebuild (the queue is memory-keyed). Closing must still drop the object's
  * now-stale entity + edges from the graph, so we remove them directly here. Fail-soft
- * like `markGraphDirty` (never throws into the E2 close caller; graph staleness is
+ * like `markGraphDirty` (never throws into the object close caller; graph staleness is
  * recoverable). Deleting the entity cascade-deletes any relation where it is an endpoint
  * (relations FK entities ON DELETE CASCADE); the explicit relations DELETE also covers a
  * relation whose OWN provenance is this object (defensive — every such edge has the object

package/dist/graph-extract.d.ts

@@ -1,16 +1,15 @@
 /**
- * E3.1 deterministic entity extraction (first slice)
- * (docs/plans/2026-06-01-e3-deterministic-extraction.md).
+ * Deterministic entity extraction.
  *
- * Populates the E3 graph from the already-structured consolidated E2-object tables -
+ * Populates the graph from the already-structured consolidated first-class object tables -
  * NO NLP, no precision gate for entities + supersedes. The graph is a pure derived
- * function of the current E2 state, so `extractGraph` is an idempotent REBUILD: clear
+ * function of the current object state, so `extractGraph` is an idempotent REBUILD: clear
  * the tenant's graph, then re-derive entities + `supersedes` relations from decisions /
- * policies / customer_notes / project_briefs (the four E2 types whose kind maps to the
+ * policies / customer_notes / project_briefs (the four object types whose kind maps to the
  * `entity_type` enum). All writes go through the src/graph.ts consolidated-source guard
  * (insertEntity / insertRelation / clearGraph); this module issues no raw SQL.
  *
- * Pass 3 (E3 cross-object, docs/plans/2026-06-02-e3-cross-object-references.md) adds the
+ * Pass 3 adds the
  * first CROSS-OBJECT relations: a deterministic NAME-MATCH heuristic that emits a
  * `references` edge when one consolidated object's text contains another entity's name.
  * It is conservative (word-boundary, length-bounded, ambiguity-guarded, per-source
@@ -47,9 +46,9 @@ export interface ExtractResult {
     truncated: string[];
 }
 /**
- * Idempotent rebuild of the tenant's deterministic graph from its consolidated E2
+ * Idempotent rebuild of the tenant's deterministic graph from its consolidated first-class
  * objects. Returns the entity/relation counts (+ which types were truncated at the
- * per-type cap). Safe to re-run: output is a pure function of the current E2 state.
+ * per-type cap). Safe to re-run: output is a pure function of the current object state.
  */
 export declare function extractGraph(hippoRoot: string, tenantId: string): ExtractResult;
 //# sourceMappingURL=graph-extract.d.ts.map