@shadowforge0/aquifer-memory 1.8.1 → 1.9.1

package/core/memory-recall.js

@@ -1,27 +1,14 @@
 'use strict';
 
 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 = {
@@ -30,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
@@ -104,6 +71,7 @@ function isActiveVisible(record, opts = {}) {
 }
 
 function activeScopeKeys(opts = {}) {
+  assertAllowedScopeRequest(opts);
   if (Array.isArray(opts.activeScopePath) && opts.activeScopePath.length > 0) {
     return opts.activeScopePath.map(value => String(value)).filter(Boolean);
   }
@@ -221,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;
 }
@@ -258,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,
@@ -274,6 +242,26 @@ function recallMemoryRecords(records = [], query, opts = {}) {
 }
 
 function createMemoryRecall({ pool, schema, defaultTenantId }) {
+  async function withResolvedScopeKey(opts = {}) {
+    const next = { ...opts };
+    if (!next.scopeId) return next;
+    const tenantId = next.tenantId || defaultTenantId;
+    const result = await pool.query(
+      `SELECT scope_key FROM ${schema}.scopes WHERE tenant_id = $1 AND id = $2 LIMIT 1`,
+      [tenantId, next.scopeId],
+    );
+    const resolvedScopeKey = result.rows?.[0]?.scope_key || null;
+    if (resolvedScopeKey) {
+      next.resolvedScopeKey = resolvedScopeKey;
+      if (!next.activeScopeKey && !next.activeScopePath) {
+        next.activeScopePath = [resolvedScopeKey];
+        next.activeScopeKey = resolvedScopeKey;
+      }
+    }
+    assertAllowedScopeRequest(next);
+    return next;
+  }
+
   function applyCurrentMemoryFilters(where, params, opts = {}) {
     const scopeKeys = activeScopeKeys(opts);
     if (opts.scopeId) {
@@ -295,18 +283,22 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
   }
 
   async function recall(query, opts = {}) {
+    const scopedOpts = await withResolvedScopeKey(opts);
     const q = String(query || '').trim();
     if (!q) throw new Error('memory.recall(query): query must be a non-empty string');
-    const tenantId = opts.tenantId || defaultTenantId;
-    const limit = Math.max(1, Math.min(50, opts.limit || 10));
-    const cfg = (opts.ftsConfig === 'zhcfg' || opts.ftsConfig === 'simple') ? opts.ftsConfig : 'simple';
-    const scopeKeys = activeScopeKeys(opts);
+    const tenantId = scopedOpts.tenantId || defaultTenantId;
+    const limit = Math.max(1, Math.min(50, scopedOpts.limit || 10));
+    const cfg = (scopedOpts.ftsConfig === 'zhcfg' || scopedOpts.ftsConfig === 'simple') ? scopedOpts.ftsConfig : 'simple';
+    const scopeKeys = activeScopeKeys(scopedOpts);
     const fetchLimit = Math.max(limit, Math.min(200, scopeKeys ? limit * 4 : limit));
     const feedbackScoreExpr = feedbackScoreSql(schema);
     const params = [tenantId, q];
     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 || '%'
@@ -314,7 +306,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
         OR m.context_key ILIKE '%' || $2 || '%'
         OR m.topic_key ILIKE '%' || $2 || '%')`,
     ];
-    applyCurrentMemoryFilters(where, params, opts);
+    applyCurrentMemoryFilters(where, params, scopedOpts);
     params.push(fetchLimit);
     const result = await pool.query(
       `SELECT
@@ -329,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,
@@ -340,7 +332,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       params
     );
     const applicableRows = scopeKeys
-      ? resolveApplicableRecords(result.rows, opts)
+      ? resolveApplicableRecords(result.rows, scopedOpts)
       : result.rows;
     return applicableRows
       .sort(sortRecallRows)
@@ -348,21 +340,25 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
   }
 
   async function recallViaEvidenceItems(query, opts = {}) {
+    const scopedOpts = await withResolvedScopeKey(opts);
     const q = String(query || '').trim();
     if (!q) throw new Error('memory.recall(query): query must be a non-empty string');
-    const tenantId = opts.tenantId || defaultTenantId;
-    const limit = Math.max(1, Math.min(50, opts.limit || 10));
-    const scopeKeys = activeScopeKeys(opts);
+    const tenantId = scopedOpts.tenantId || defaultTenantId;
+    const limit = Math.max(1, Math.min(50, scopedOpts.limit || 10));
+    const scopeKeys = activeScopeKeys(scopedOpts);
     const fetchLimit = Math.max(limit, Math.min(200, scopeKeys ? limit * 4 : limit));
     const feedbackScoreExpr = feedbackScoreSql(schema);
     const params = [tenantId, q];
     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, opts);
-    const queryVec = vecToStr(opts.queryVec);
+    applyCurrentMemoryFilters(where, params, scopedOpts);
+    const queryVec = vecToStr(scopedOpts.queryVec);
     let vectorScoreExpr = '0';
     let evidencePredicate = `(ei.excerpt_text ILIKE '%' || $2 || '%'
              OR ei.search_tsv @@ plainto_tsquery('simple', $2))`;
@@ -370,7 +366,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       params.push(queryVec);
       const vecPos = params.length;
       vectorScoreExpr = `COALESCE(1.0 - (ei.embedding <=> $${vecPos}::vector), 0)`;
-      evidencePredicate = opts.vectorOnly === true
+      evidencePredicate = scopedOpts.vectorOnly === true
         ? `ei.embedding IS NOT NULL`
         : `(${evidencePredicate} OR ei.embedding IS NOT NULL)`;
     }
@@ -379,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 (
@@ -425,7 +421,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       params,
     );
     const applicableRows = scopeKeys
-      ? resolveApplicableRecords(result.rows, opts)
+      ? resolveApplicableRecords(result.rows, scopedOpts)
       : result.rows;
     return applicableRows
       .sort(sortRecallRows)
@@ -433,21 +429,25 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
   }
 
   async function recallViaMemoryEmbeddings(queryVec, opts = {}) {
+    const scopedOpts = await withResolvedScopeKey(opts);
     const vector = vecToStr(queryVec);
     if (!vector) return [];
-    const tenantId = opts.tenantId || defaultTenantId;
-    const limit = Math.max(1, Math.min(50, opts.limit || 10));
-    const scopeKeys = activeScopeKeys(opts);
+    const tenantId = scopedOpts.tenantId || defaultTenantId;
+    const limit = Math.max(1, Math.min(50, scopedOpts.limit || 10));
+    const scopeKeys = activeScopeKeys(scopedOpts);
     const fetchLimit = Math.max(limit, Math.min(200, scopeKeys ? limit * 4 : limit));
     const feedbackScoreExpr = feedbackScoreSql(schema);
     const params = [tenantId, vector];
     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`,
     ];
-    applyCurrentMemoryFilters(where, params, opts);
+    applyCurrentMemoryFilters(where, params, scopedOpts);
     params.push(fetchLimit);
     const result = await pool.query(
       `SELECT
@@ -463,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,
@@ -473,7 +473,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       params,
     );
     const applicableRows = scopeKeys
-      ? resolveApplicableRecords(result.rows, opts)
+      ? resolveApplicableRecords(result.rows, scopedOpts)
       : result.rows;
     return applicableRows
       .sort(sortRecallRows)
@@ -481,26 +481,30 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
   }
 
   async function recallViaLinkedSummaryEmbeddings(queryVec, opts = {}) {
+    const scopedOpts = await withResolvedScopeKey(opts);
     const vector = vecToStr(queryVec);
     if (!vector) return [];
-    const tenantId = opts.tenantId || defaultTenantId;
-    const limit = Math.max(1, Math.min(50, opts.limit || 10));
-    const scopeKeys = activeScopeKeys(opts);
+    const tenantId = scopedOpts.tenantId || defaultTenantId;
+    const limit = Math.max(1, Math.min(50, scopedOpts.limit || 10));
+    const scopeKeys = activeScopeKeys(scopedOpts);
     const fetchLimit = Math.max(limit, Math.min(200, scopeKeys ? limit * 4 : limit));
     const feedbackScoreExpr = feedbackScoreSql(schema);
     const params = [tenantId, vector];
     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, opts);
+    applyCurrentMemoryFilters(where, params, scopedOpts);
     params.push(fetchLimit);
     const result = await pool.query(
       `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 (
@@ -543,7 +547,7 @@ function createMemoryRecall({ pool, schema, defaultTenantId }) {
       params,
     );
     const applicableRows = scopeKeys
-      ? resolveApplicableRecords(result.rows, opts)
+      ? resolveApplicableRecords(result.rows, scopedOpts)
       : result.rows;
     return applicableRows
       .sort(sortRecallRows)