@shadowforge0/aquifer-memory 1.9.0 → 1.9.1

package/core/memory-recall.js

@@ -3,26 +3,12 @@
 const { resolveApplicableRecords } = require('./memory-bootstrap');
 const { assertAllowedScopeRequest } = require('./memory-serving');
 const { hybridRank } = require('./hybrid-rank');
-
-const TYPE_RANK = {
-  constraint: 80,
-  preference: 70,
-  state: 60,
-  open_loop: 55,
-  decision: 50,
-  fact: 40,
-  conclusion: 30,
-  entity_note: 20,
-};
-
-const FEEDBACK_WEIGHT = {
-  helpful: 0.15,
-  confirm: 0.10,
-  irrelevant: -0.20,
-  scope_mismatch: -0.25,
-  stale: -0.30,
-  incorrect: -0.50,
-};
+const {
+  feedbackWeight,
+  feedbackWeightSql,
+  memoryTypeRecallRank,
+  memoryTypeRecallRankSql,
+} = require('./memory-type-policy');
 
 const RETRIEVAL_TYPE_BOOST = 0.05;
 const SIGNAL_PRIORITY = {
@@ -31,34 +17,14 @@ const SIGNAL_PRIORITY = {
   memory_row: 3,
 };
 
-const TYPE_RANK_SQL = `
-  CASE m.memory_type
-    WHEN 'constraint' THEN 0.80
-    WHEN 'preference' THEN 0.70
-    WHEN 'state' THEN 0.60
-    WHEN 'open_loop' THEN 0.55
-    WHEN 'decision' THEN 0.50
-    WHEN 'fact' THEN 0.40
-    WHEN 'conclusion' THEN 0.30
-    WHEN 'entity_note' THEN 0.20
-    ELSE 0
-  END`;
-
+const TYPE_RANK_SQL = memoryTypeRecallRankSql('m.memory_type');
 const TYPE_BOOST_SQL = `(${TYPE_RANK_SQL}) * ${RETRIEVAL_TYPE_BOOST}`;
 
 function feedbackScoreSql(schema) {
   return `
     COALESCE((
       SELECT SUM(
-        CASE f.feedback_type
-          WHEN 'helpful' THEN 0.15
-          WHEN 'confirm' THEN 0.10
-          WHEN 'irrelevant' THEN -0.20
-          WHEN 'scope_mismatch' THEN -0.25
-          WHEN 'stale' THEN -0.30
-          WHEN 'incorrect' THEN -0.50
-          ELSE 0
-        END
+        ${feedbackWeightSql('f.feedback_type')}
       )
       FROM ${schema}.feedback f
       WHERE f.tenant_id = $1
@@ -223,7 +189,7 @@ function feedbackScore(record, feedbackEvents = []) {
     const targetId = String(event.targetId || event.target_id || '');
     if (targetId !== id) continue;
     const type = event.feedbackType || event.feedback_type || event.verdict;
-    score += FEEDBACK_WEIGHT[type] || 0;
+    score += feedbackWeight(type);
   }
   return score;
 }
@@ -260,7 +226,7 @@ function recallMemoryRecords(records = [], query, opts = {}) {
     .map(record => {
       const haystack = textOf(record).toLowerCase();
       const lexical = lexicalScore(haystack, q);
-      const typeRank = ((TYPE_RANK[record.memoryType || record.memory_type] || 0) / 100) * RETRIEVAL_TYPE_BOOST;
+      const typeRank = (memoryTypeRecallRank(record.memoryType || record.memory_type) / 100) * RETRIEVAL_TYPE_BOOST;
       const feedback = feedbackScore(record, feedbackEvents);
       return {
         ...record,
@@ -330,6 +296,9 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
     const where = [
       `m.tenant_id = $1`,
       `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
       `m.visible_in_recall = true`,
       `(m.search_tsv @@ plainto_tsquery('${cfg}', $2)
         OR m.title ILIKE '%' || $2 || '%'
@@ -352,7 +321,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
            + ${TYPE_BOOST_SQL}
            + ${feedbackScoreExpr} AS recall_score
        FROM ${schema}.memory_records m
-       JOIN ${schema}.scopes s ON s.id = m.scope_id
+       JOIN ${schema}.scopes s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
        WHERE ${where.join(' AND ')}
        ORDER BY
          title_match DESC,
@@ -383,6 +352,9 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
     const where = [
       `m.tenant_id = $1`,
       `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
       `m.visible_in_recall = true`,
     ];
     applyCurrentMemoryFilters(where, params, scopedOpts);
@@ -403,7 +375,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       `WITH eligible_memories AS (
          SELECT m.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode
          FROM ${schema}.memory_records m
-         JOIN ${schema}.scopes s ON s.id = m.scope_id
+         JOIN ${schema}.scopes s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
          WHERE ${where.join(' AND ')}
        ),
        evidence_hits AS (
@@ -469,6 +441,9 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
     const where = [
       `m.tenant_id = $1`,
       `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
       `m.visible_in_recall = true`,
       `m.embedding IS NOT NULL`,
     ];
@@ -488,7 +463,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
            + ${TYPE_BOOST_SQL}
            + ${feedbackScoreExpr} AS recall_score
        FROM ${schema}.memory_records m
-       JOIN ${schema}.scopes s ON s.id = m.scope_id
+       JOIN ${schema}.scopes s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
        WHERE ${where.join(' AND ')}
        ORDER BY
          m.embedding <=> $2::vector ASC,
@@ -518,6 +493,9 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
     const where = [
       `m.tenant_id = $1`,
       `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
       `m.visible_in_recall = true`,
     ];
     applyCurrentMemoryFilters(where, params, scopedOpts);
@@ -526,7 +504,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       `WITH eligible_memories AS (
          SELECT m.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode
          FROM ${schema}.memory_records m
-         JOIN ${schema}.scopes s ON s.id = m.scope_id
+         JOIN ${schema}.scopes s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
          WHERE ${where.join(' AND ')}
        ),
        linked_summary_hits AS (

package/core/memory-records.js

@@ -3,6 +3,14 @@
 const crypto = require('crypto');
 const { resolveApplicableRecords } = require('./memory-bootstrap');
 const { assertAllowedScopeRequest } = require('./memory-serving');
+const {
+  authoritySortPriority,
+  authoritySortPrioritySql,
+  feedbackWeightSql,
+  memoryTypeBootstrapPriority,
+  memoryTypeBootstrapPrioritySql,
+  memoryTypeRuntimeContract,
+} = require('./memory-type-policy');
 
 function requireField(obj, field) {
   if (!obj || obj[field] === undefined || obj[field] === null || obj[field] === '') {
@@ -31,57 +39,33 @@ function advisoryLockKeys(namespace, value) {
   return [digest.readInt32BE(0), digest.readInt32BE(4)];
 }
 
-const BOOTSTRAP_ORDER_SQL = `
-         CASE m.memory_type
-           WHEN 'constraint' THEN 0
-           WHEN 'state' THEN 1
-           WHEN 'open_loop' THEN 2
-           WHEN 'decision' THEN 3
-           WHEN 'preference' THEN 4
-           WHEN 'fact' THEN 5
-           WHEN 'conclusion' THEN 6
-           WHEN 'entity_note' THEN 7
-           ELSE 99
-         END ASC,
-         CASE m.authority
-           WHEN 'user_explicit' THEN 0
-           WHEN 'executable_evidence' THEN 1
-           WHEN 'manual' THEN 2
-           WHEN 'system' THEN 3
-           WHEN 'verified_summary' THEN 4
-           WHEN 'llm_inference' THEN 5
-           WHEN 'raw_transcript' THEN 6
-           ELSE 99
-         END ASC,
+function bootstrapOrderSql(feedbackScoreExpr = '0') {
+  return `
+         ${memoryTypeBootstrapPrioritySql('m.memory_type')} ASC,
+         ${authoritySortPrioritySql('m.authority')} ASC,
+         COALESCE((${feedbackScoreExpr}), 0) DESC,
          m.accepted_at DESC NULLS LAST,
          m.id ASC`;
-
-const CURRENT_TYPE_PRIORITY = {
-  constraint: 0,
-  state: 1,
-  open_loop: 2,
-  decision: 3,
-  preference: 4,
-  fact: 5,
-  conclusion: 6,
-  entity_note: 7,
-};
-
-const CURRENT_AUTHORITY_PRIORITY = {
-  user_explicit: 0,
-  executable_evidence: 1,
-  manual: 2,
-  system: 3,
-  verified_summary: 4,
-  llm_inference: 5,
-  raw_transcript: 6,
-};
+}
 
 function parseTime(value) {
   const parsed = Date.parse(value || '');
   return Number.isFinite(parsed) ? parsed : null;
 }
 
+function memoryFeedbackScoreSql(feedbackTable, feedbackTableAlias = 'f') {
+  return `
+    COALESCE((
+      SELECT SUM(
+        ${feedbackWeightSql(`${feedbackTableAlias}.feedback_type`)}
+      )
+      FROM ${feedbackTable} ${feedbackTableAlias}
+      WHERE ${feedbackTableAlias}.tenant_id = m.tenant_id
+        AND ${feedbackTableAlias}.target_kind = 'memory_record'
+        AND ${feedbackTableAlias}.target_id = m.id::text
+    ), 0)`;
+}
+
 function normalizeScopePath(activeScopePath, activeScopeKey) {
   const source = Array.isArray(activeScopePath)
     ? activeScopePath
@@ -128,6 +112,7 @@ function normalizeCurrentMemoryRow(row = {}) {
     inheritanceMode: row.inheritanceMode ?? row.inheritance_mode ?? row.scope_inheritance_mode ?? null,
     visibleInBootstrap: row.visibleInBootstrap ?? row.visible_in_bootstrap ?? false,
     visibleInRecall: row.visibleInRecall ?? row.visible_in_recall ?? false,
+    feedbackScore: Number(row.feedbackScore ?? row.feedback_score) || 0,
     acceptedAt: row.acceptedAt ?? row.accepted_at ?? null,
     validFrom: row.validFrom ?? row.valid_from ?? null,
     validTo: row.validTo ?? row.valid_to ?? null,
@@ -142,18 +127,26 @@ function currentScopePriority(record, positions) {
 }
 
 function sortCurrentMemoryRecords(a, b, positions) {
+  const leftRuntimeContract = memoryTypeRuntimeContract(a.memoryType ?? a.memory_type);
+  const rightRuntimeContract = memoryTypeRuntimeContract(b.memoryType ?? b.memory_type);
+  if (leftRuntimeContract !== rightRuntimeContract) return leftRuntimeContract ? -1 : 1;
+
   const leftScope = currentScopePriority(a, positions);
   const rightScope = currentScopePriority(b, positions);
   if (rightScope !== leftScope) return rightScope - leftScope;
 
-  const leftType = CURRENT_TYPE_PRIORITY[a.memoryType ?? a.memory_type] ?? 99;
-  const rightType = CURRENT_TYPE_PRIORITY[b.memoryType ?? b.memory_type] ?? 99;
+  const leftType = memoryTypeBootstrapPriority(a.memoryType ?? a.memory_type);
+  const rightType = memoryTypeBootstrapPriority(b.memoryType ?? b.memory_type);
   if (leftType !== rightType) return leftType - rightType;
 
-  const leftAuthority = CURRENT_AUTHORITY_PRIORITY[a.authority] ?? 99;
-  const rightAuthority = CURRENT_AUTHORITY_PRIORITY[b.authority] ?? 99;
+  const leftAuthority = authoritySortPriority(a.authority);
+  const rightAuthority = authoritySortPriority(b.authority);
   if (leftAuthority !== rightAuthority) return leftAuthority - rightAuthority;
 
+  const leftFeedback = Number(a.feedbackScore ?? a.feedback_score) || 0;
+  const rightFeedback = Number(b.feedbackScore ?? b.feedback_score) || 0;
+  if (leftFeedback !== rightFeedback) return rightFeedback - leftFeedback;
+
   const leftAccepted = parseTime(a.acceptedAt ?? a.accepted_at);
   const rightAccepted = parseTime(b.acceptedAt ?? b.accepted_at);
   if (leftAccepted !== rightAccepted) return (rightAccepted ?? 0) - (leftAccepted ?? 0);
@@ -270,29 +263,7 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
          COALESCE($10,'candidate'),COALESCE($11,'llm_inference'),$12,$13,$14,$15,
          $16,$17,$18,$19,$20,$21,COALESCE($22,false),COALESCE($23,false),COALESCE($24::jsonb,'{}'::jsonb),$25,$26,$27::vector
        )
-       ON CONFLICT (tenant_id, canonical_key) WHERE status = 'active' DO UPDATE SET
-         scope_id = EXCLUDED.scope_id,
-         context_key = COALESCE(EXCLUDED.context_key, ${memories}.context_key),
-         topic_key = COALESCE(EXCLUDED.topic_key, ${memories}.topic_key),
-         title = COALESCE(EXCLUDED.title, ${memories}.title),
-         summary = COALESCE(NULLIF(EXCLUDED.summary, ''), ${memories}.summary),
-         payload = COALESCE(NULLIF(EXCLUDED.payload, '{}'::jsonb), ${memories}.payload),
-         authority = EXCLUDED.authority,
-         accepted_at = COALESCE(EXCLUDED.accepted_at, ${memories}.accepted_at),
-         valid_from = COALESCE(EXCLUDED.valid_from, ${memories}.valid_from),
-         valid_to = COALESCE(EXCLUDED.valid_to, ${memories}.valid_to),
-         stale_after = COALESCE(EXCLUDED.stale_after, ${memories}.stale_after),
-         version_id = COALESCE(EXCLUDED.version_id, ${memories}.version_id),
-         backing_fact_id = COALESCE(EXCLUDED.backing_fact_id, ${memories}.backing_fact_id),
-         observed_at = COALESCE(EXCLUDED.observed_at, ${memories}.observed_at),
-         revoked_at = COALESCE(EXCLUDED.revoked_at, ${memories}.revoked_at),
-         superseded_at = COALESCE(EXCLUDED.superseded_at, ${memories}.superseded_at),
-         visible_in_bootstrap = EXCLUDED.visible_in_bootstrap,
-         visible_in_recall = EXCLUDED.visible_in_recall,
-         rank_features = COALESCE(NULLIF(EXCLUDED.rank_features, '{}'::jsonb), ${memories}.rank_features),
-         created_by_finalization_id = COALESCE(${memories}.created_by_finalization_id, EXCLUDED.created_by_finalization_id),
-         created_by_compaction_run_id = COALESCE(${memories}.created_by_compaction_run_id, EXCLUDED.created_by_compaction_run_id),
-         embedding = COALESCE(EXCLUDED.embedding, ${memories}.embedding)
+       ON CONFLICT (tenant_id, canonical_key) WHERE status = 'active' DO NOTHING
        RETURNING *`,
       [
         tenantId,
@@ -349,28 +320,7 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
          $10,$11,$12,$13,$14,$15,$16,COALESCE($17,'active'),COALESCE($18,'verified_summary'),
          $19,$20,$21,COALESCE($22::jsonb,'{}'::jsonb),$23,$24
        )
-       ON CONFLICT (tenant_id, canonical_key) WHERE status = 'active' DO UPDATE SET
-         scope_id = EXCLUDED.scope_id,
-         subject_entity_id = COALESCE(EXCLUDED.subject_entity_id, ${factAssertions}.subject_entity_id),
-         predicate = EXCLUDED.predicate,
-         object_kind = EXCLUDED.object_kind,
-         object_entity_id = COALESCE(EXCLUDED.object_entity_id, ${factAssertions}.object_entity_id),
-         object_value_json = EXCLUDED.object_value_json,
-         qualifiers_json = COALESCE(NULLIF(EXCLUDED.qualifiers_json, '{}'::jsonb), ${factAssertions}.qualifiers_json),
-         valid_from = COALESCE(EXCLUDED.valid_from, ${factAssertions}.valid_from),
-         valid_to = COALESCE(EXCLUDED.valid_to, ${factAssertions}.valid_to),
-         observed_at = COALESCE(EXCLUDED.observed_at, ${factAssertions}.observed_at),
-         stale_after = COALESCE(EXCLUDED.stale_after, ${factAssertions}.stale_after),
-         accepted_at = COALESCE(EXCLUDED.accepted_at, ${factAssertions}.accepted_at),
-         revoked_at = COALESCE(EXCLUDED.revoked_at, ${factAssertions}.revoked_at),
-         superseded_at = COALESCE(EXCLUDED.superseded_at, ${factAssertions}.superseded_at),
-         authority = EXCLUDED.authority,
-         assertion_hash = EXCLUDED.assertion_hash,
-         version_id = COALESCE(EXCLUDED.version_id, ${factAssertions}.version_id),
-         metadata = COALESCE(NULLIF(EXCLUDED.metadata, '{}'::jsonb), ${factAssertions}.metadata),
-         created_by_finalization_id = COALESCE(${factAssertions}.created_by_finalization_id, EXCLUDED.created_by_finalization_id),
-         created_by_compaction_run_id = COALESCE(${factAssertions}.created_by_compaction_run_id, EXCLUDED.created_by_compaction_run_id),
-         updated_at = now()
+       ON CONFLICT (tenant_id, canonical_key) WHERE status = 'active' DO NOTHING
        RETURNING *`,
       [
         tenantId,
@@ -524,10 +474,13 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const result = await pool.query(
       `SELECT m.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode
        FROM ${memories} m
-       JOIN ${scopes} s ON s.id = m.scope_id
+       JOIN ${scopes} s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
        WHERE m.tenant_id = $1
          AND m.canonical_key = $2
          AND m.status = 'active'
+         AND m.revoked_at IS NULL
+         AND m.superseded_at IS NULL
+         AND m.superseded_by IS NULL
        ORDER BY m.accepted_at DESC NULLS LAST, m.id ASC
        ${lockClause}`,
       [tenantId, input.canonicalKey]
@@ -542,10 +495,13 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const result = await pool.query(
       `SELECT f.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode
        FROM ${factAssertions} f
-       JOIN ${scopes} s ON s.id = f.scope_id
+       JOIN ${scopes} s ON s.tenant_id = f.tenant_id AND s.id = f.scope_id
        WHERE f.tenant_id = $1
          AND f.canonical_key = $2
          AND f.status = 'active'
+         AND f.revoked_at IS NULL
+         AND f.superseded_at IS NULL
+         AND f.superseded_by IS NULL
        ORDER BY f.accepted_at DESC NULLS LAST, f.id ASC
        ${lockClause}`,
       [tenantId, input.canonicalKey]
@@ -572,14 +528,19 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const result = await pool.query(
       `UPDATE ${memories}
        SET status = $3,
-           superseded_by = COALESCE($4, superseded_by),
+           superseded_by = CASE
+             WHEN $3 = 'active' THEN NULL
+             ELSE COALESCE($4, superseded_by)
+           END,
            valid_to = COALESCE($5, valid_to),
            superseded_at = CASE
              WHEN $3 = 'superseded' THEN COALESCE($8, superseded_at, now())
+             WHEN $3 = 'active' THEN NULL
              ELSE superseded_at
            END,
            revoked_at = CASE
              WHEN $3 = 'revoked' THEN COALESCE($9, revoked_at, now())
+             WHEN $3 = 'active' THEN NULL
              ELSE revoked_at
            END,
            visible_in_bootstrap = $6,
@@ -612,14 +573,19 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const result = await pool.query(
       `UPDATE ${memories}
        SET status = $4,
-           superseded_by = COALESCE($5, superseded_by),
+           superseded_by = CASE
+             WHEN $4 = 'active' THEN NULL
+             ELSE COALESCE($5, superseded_by)
+           END,
            valid_to = COALESCE($6, valid_to),
            superseded_at = CASE
              WHEN $4 = 'superseded' THEN COALESCE($9, superseded_at, now())
+             WHEN $4 = 'active' THEN NULL
              ELSE superseded_at
            END,
            revoked_at = CASE
              WHEN $4 = 'revoked' THEN COALESCE($10, revoked_at, now())
+             WHEN $4 = 'active' THEN NULL
              ELSE revoked_at
            END,
            visible_in_bootstrap = $7,
@@ -650,14 +616,19 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const result = await pool.query(
       `UPDATE ${factAssertions}
        SET status = $3,
-           superseded_by = COALESCE($4, superseded_by),
+           superseded_by = CASE
+             WHEN $3 = 'active' THEN NULL
+             ELSE COALESCE($4, superseded_by)
+           END,
            valid_to = COALESCE($5, valid_to),
            superseded_at = CASE
              WHEN $3 = 'superseded' THEN COALESCE($6, superseded_at, now())
+             WHEN $3 = 'active' THEN NULL
              ELSE superseded_at
            END,
            revoked_at = CASE
              WHEN $3 = 'revoked' THEN COALESCE($7, revoked_at, now())
+             WHEN $3 = 'active' THEN NULL
              ELSE revoked_at
            END,
            updated_at = now()
@@ -679,7 +650,13 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
   async function listActive(input = {}) {
     const tenantId = input.tenantId || defaultTenantId;
     const params = [tenantId];
-    const where = [`m.tenant_id = $1`, `m.status = 'active'`];
+    const where = [
+      `m.tenant_id = $1`,
+      `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
+    ];
     if (input.asOf) {
       params.push(input.asOf);
       const at = `$${params.length}::timestamptz`;
@@ -707,13 +684,18 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
       where.push(`m.embedding IS NULL`);
     }
     params.push(Math.max(1, Math.min(200, input.limit || 50)));
+    const feedbackScoreExpr = input.includeFeedbackScore === true
+      ? memoryFeedbackScoreSql(feedback)
+      : '0';
+    const feedbackScoreSelect = `${feedbackScoreExpr}::real AS feedback_score`;
     const orderBy = input.visibleInBootstrap === true
-      ? BOOTSTRAP_ORDER_SQL
+      ? bootstrapOrderSql(feedbackScoreExpr)
       : `m.accepted_at DESC NULLS LAST, m.id ASC`;
     const result = await pool.query(
-      `SELECT m.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode
+      `SELECT m.*, s.scope_kind, s.scope_key, s.inheritance_mode AS scope_inheritance_mode,
+              ${feedbackScoreSelect}
        FROM ${memories} m
-       JOIN ${scopes} s ON s.id = m.scope_id
+       JOIN ${scopes} s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
        WHERE ${where.join(' AND ')}
        ORDER BY ${orderBy}
        LIMIT $${params.length}`,
@@ -802,6 +784,9 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const where = [
       `m.tenant_id = $1`,
       `m.status = 'active'`,
+      `m.revoked_at IS NULL`,
+      `m.superseded_at IS NULL`,
+      `m.superseded_by IS NULL`,
       `s.scope_key = ANY($2::text[])`,
       `(m.visible_in_bootstrap = true OR m.visible_in_recall = true)`,
       `(m.valid_from IS NULL OR m.valid_from <= $3::timestamptz)`,
@@ -836,18 +821,21 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
          ), '[]'::jsonb)`
       : `'[]'::jsonb`;
 
+    const feedbackScoreExpr = memoryFeedbackScoreSql(feedback);
+    const feedbackScoreSelect = `${feedbackScoreExpr}::real AS feedback_score`;
     const result = await pool.query(
       `SELECT
          m.*,
          s.scope_kind,
          s.scope_key,
          s.inheritance_mode AS scope_inheritance_mode,
+         ${feedbackScoreSelect},
          ${evidenceRefsSelect} AS evidence_refs
        FROM ${memories} m
-       JOIN ${scopes} s ON s.id = m.scope_id
+       JOIN ${scopes} s ON s.tenant_id = m.tenant_id AND s.id = m.scope_id
        WHERE ${where.join(' AND ')}
        ORDER BY array_position($2::text[], s.scope_key) DESC NULLS LAST,
-                ${BOOTSTRAP_ORDER_SQL}
+                ${bootstrapOrderSql(feedbackScoreExpr)}
        LIMIT ${limitParam}`,
       params,
     );