@shadowforge0/aquifer-memory 1.8.1 → 1.9.1

package/core/memory-records.js

@@ -2,6 +2,15 @@
 
 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] === '') {
@@ -30,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
@@ -127,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,
@@ -141,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);
@@ -269,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,
@@ -348,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,
@@ -523,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]
@@ -541,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]
@@ -571,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,
@@ -611,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,
@@ -649,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()
@@ -678,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`;
@@ -706,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}`,
@@ -773,17 +756,27 @@ function createMemoryRecords({ pool, schema, defaultTenantId, inTransaction = fa
     const tenantId = input.tenantId || defaultTenantId;
     let activeScopePath = normalizeScopePath(input.activeScopePath, input.activeScopeKey);
     let activeScopeKey = input.activeScopeKey || activeScopePath[activeScopePath.length - 1] || null;
-    if (input.scopeId && !input.activeScopeKey && !input.activeScopePath) {
+    let resolvedScopeKey = null;
+    if (input.scopeId) {
       const scopeResult = await pool.query(
         `SELECT scope_key FROM ${scopes} WHERE tenant_id = $1 AND id = $2 LIMIT 1`,
         [tenantId, input.scopeId],
       );
-      const scopedKey = scopeResult.rows[0]?.scope_key || null;
-      if (scopedKey) {
-        activeScopePath = [scopedKey];
-        activeScopeKey = scopedKey;
+      resolvedScopeKey = scopeResult.rows[0]?.scope_key || null;
+      if (resolvedScopeKey && !input.activeScopeKey && !input.activeScopePath) {
+        activeScopePath = [resolvedScopeKey];
+        activeScopeKey = resolvedScopeKey;
       }
     }
+    assertAllowedScopeRequest({
+      ...input,
+      activeScopeKey,
+      activeScopePath,
+      resolvedScopeKey,
+    });
+    if (input.includeEvidenceRefs === true && input.operator !== true && input.internal !== true) {
+      throw new Error('memory.current includeEvidenceRefs requires operator=true or internal=true');
+    }
     const limit = Math.max(1, Math.min(100, input.limit || 50));
     const fetchLimit = Math.max(limit + 1, Math.min(200, Math.max(limit * 4, 40)));
     const asOf = input.asOf || new Date().toISOString();
@@ -791,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)`,
@@ -825,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,
     );