@equilateral_ai/mindmeld 3.5.0 → 3.5.2

package/src/handlers/standards/standardsRelevantPost.js

@@ -11,12 +11,13 @@
  * Body: { characteristics, projectId?, preferences? }
  */
 
-const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, getPredictedStandards, logStandardsActivation, createFrame } = require('./helpers');
 
 /**
  * Category weights for relevance scoring
  */
 const CATEGORY_WEIGHTS = {
+    // Code standard categories
     'serverless-saas-aws': 1.0,
     'frontend-development': 1.0,
     'database': 0.9,
@@ -28,6 +29,16 @@ const CATEGORY_WEIGHTS = {
     'well-architected': 0.7,
     'cost-optimization': 0.7,
     'multi-agent-orchestration': 0.1,  // Infrastructure config, rarely needed in coding sessions
+    // Business domains — moderate weights, boosted by recency when relevant
+    'ip-strategy': 0.6,
+    'architecture-decisions': 0.8,
+    'go-to-market': 0.6,
+    'operations': 0.5,
+    'legal-process': 0.5,
+    'finance': 0.5,
+    'communication': 0.4,
+    'product-strategy': 0.6,
+    'investor-relations': 0.4,
 };
 
 /**
@@ -76,8 +87,8 @@ function rankStandards(standards, recentCategories) {
         // Base score from correlation
         score += (standard.correlation || 1.0) * 40;
 
-        // Maturity score
-        const maturityScores = { enforced: 30, validated: 20, recommended: 10, provisional: 5 };
+        // Maturity score (includes business invariant lifecycle values)
+        const maturityScores = { enforced: 30, reinforced: 25, validated: 20, solidified: 15, recommended: 10, provisional: 5 };
         score += maturityScores[standard.maturity] || 0;
 
         // Category weight
@@ -107,6 +118,9 @@ function rankStandards(standards, recentCategories) {
             || (Array.isArray(standard.keywords) && standard.keywords.includes('workflow'));
         if (isWorkflow) score += 10;
 
+        // Rationale bonus — business invariants with documented reasoning
+        if (standard.rationale) score += 5;
+
         // Recency bonus — boost categories the user has been working in recently
         // Scaled by category weight to prevent feedback loops (low-weight categories
         // that got injected shouldn't bootstrap themselves back into the top 10)
@@ -119,11 +133,33 @@ function rankStandards(standards, recentCategories) {
             score += rawBonus * categoryWeight;
         }
 
+        // Recency decay: patterns not seen in 30+ days get penalized
+        if (standard.last_seen_at) {
+            const daysSinceLastSeen = (Date.now() - new Date(standard.last_seen_at).getTime()) / (1000 * 60 * 60 * 24);
+            if (daysSinceLastSeen > 30) {
+                score *= 0.5;
+            }
+        }
+
+        // Frequency boost: high-occurrence patterns are more valuable
+        const occurrenceCount = standard.occurrence_count || 1;
+        if (occurrenceCount > 50) {
+            score *= 1.5;
+        } else if (occurrenceCount > 10) {
+            score *= 1.2;
+        }
+
         return {
             ...standard,
             relevance_score: Math.round(score * 10) / 10
         };
-    }).sort((a, b) => b.relevance_score - a.relevance_score);
+    }).sort((a, b) => {
+        // Load-bearing standards always sort to the top
+        const aLB = a.load_bearing ? 1 : 0;
+        const bLB = b.load_bearing ? 1 : 0;
+        if (bLB !== aLB) return bLB - aLB;
+        return b.relevance_score - a.relevance_score;
+    });
 }
 
 /**
@@ -162,17 +198,20 @@ async function getRelevantStandards({ body, requestContext }) {
         return createErrorResponse(401, 'Authentication required');
     }
 
-    // Verify active subscription — no free tier access
+    // Verify active subscription and resolve company_id for tenant isolation
     const subResult = await executeQuery(`
-        SELECT c.subscription_tier, c.subscription_status
+        SELECT c.subscription_tier, c.subscription_status, ue.company_id
         FROM rapport.users u
         JOIN rapport.clients c ON u.client_id = c.client_id
+        LEFT JOIN rapport.user_entitlements ue ON u.email_address = ue.email_address
         WHERE u.email_address = $1
         LIMIT 1
     `, [email]);
 
+    let companyId = null;
     if (subResult.rows.length > 0) {
         const { subscription_tier, subscription_status } = subResult.rows[0];
+        companyId = subResult.rows[0].company_id;
         if (!subscription_tier || subscription_tier === 'free') {
             return createErrorResponse(403, 'Active MindMeld subscription required. Subscribe at app.mindmeld.dev');
         }
@@ -234,33 +273,39 @@ async function getRelevantStandards({ body, requestContext }) {
         }
     }
 
-    // Query standards from all relevant categories (static + recency)
+    // Query standards — tenant-isolated via get_effective_standards()
+    const maturityList = ['enforced', 'validated', 'recommended', 'provisional', 'solidified', 'reinforced'];
     const result = await executeQuery(`
-        SELECT
-            pattern_id,
-            element,
-            title,
-            rule,
-            category,
-            keywords,
-            correlation,
-            maturity,
-            applicable_files,
-            anti_patterns,
-            examples,
-            cost_impact,
-            source
-        FROM rapport.standards_patterns
-        WHERE category = ANY($1::varchar[])
-            AND maturity IN ('enforced', 'validated', 'recommended')
+        SELECT * FROM rapport.get_effective_standards($1, $2::varchar[], $3::varchar[])
         ORDER BY
             CASE
                 WHEN maturity = 'enforced' THEN 1
-                WHEN maturity = 'validated' THEN 2
-                ELSE 3
+                WHEN maturity = 'reinforced' THEN 2
+                WHEN maturity = 'validated' THEN 3
+                WHEN maturity = 'solidified' THEN 4
+                WHEN maturity = 'recommended' THEN 5
+                ELSE 6
             END,
             correlation DESC
-    `, [categories]);
+    `, [companyId, categories, maturityList]);
+
+    // Predictive cache: fetch standards with >80% activation rate for this project
+    let predictedStandards = [];
+    const projectId = requestBody.projectId;
+    if (projectId) {
+        try {
+            const predicted = await getPredictedStandards(projectId);
+            if (predicted.length > 0) {
+                const predictedIds = new Set(predicted.map(p => p.standard_id));
+                // Pull predicted standards from query results and mark them as pre-cached
+                predictedStandards = result.rows
+                    .filter(s => predictedIds.has(s.pattern_id || s.standard_id))
+                    .map(s => ({ ...s, relevance_score: 100, predicted: true }));
+            }
+        } catch (err) {
+            console.error('[standardsRelevant] Predictive cache lookup failed:', err.message);
+        }
+    }
 
     // Rank by relevance with recency boost
     let ranked = rankStandards(result.rows, recentCategories);
@@ -282,26 +327,78 @@ async function getRelevantStandards({ body, requestContext }) {
     // Return top 10 with diversity caps:
     // - Max 2 per category (prevents single-category saturation)
     // - Max 1 per standard title (prevents same-file rule pairs wasting slots)
+    // Predicted standards are included first (they skip scoring)
     const MAX_PER_CATEGORY = 2;
     const MAX_PER_TITLE = 1;
     const top = [];
     const categoryCounts = {};
     const titleCounts = {};
-    for (const standard of ranked) {
+    const seenPredicted = new Set();
+
+    // Add predicted standards first — they have proven relevance
+    for (const standard of predictedStandards) {
         const cat = standard.category;
         const title = standard.title || standard.element;
+        const key = standard.element;
         categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
         titleCounts[title] = (titleCounts[title] || 0) + 1;
+        seenPredicted.add(key);
         if (categoryCounts[cat] <= MAX_PER_CATEGORY && titleCounts[title] <= MAX_PER_TITLE) {
             top.push(standard);
             if (top.length >= 10) break;
         }
     }
 
+    // Fill remaining slots from scored standards
+    for (const standard of ranked) {
+        if (top.length >= 10) break;
+        if (seenPredicted.has(standard.element)) continue;
+        const cat = standard.category;
+        const title = standard.title || standard.element;
+        categoryCounts[cat] = (categoryCounts[cat] || 0) + 1;
+        titleCounts[title] = (titleCounts[title] || 0) + 1;
+        if (categoryCounts[cat] <= MAX_PER_CATEGORY && titleCounts[title] <= MAX_PER_TITLE) {
+            top.push(standard);
+        }
+    }
+
+    // Log activated standards for future predictions
+    if (projectId && top.length > 0) {
+        const activatedIds = top
+            .map(s => s.pattern_id || s.standard_id)
+            .filter(id => id != null);
+        logStandardsActivation(projectId, activatedIds).catch(err => {
+            console.error('[standardsRelevant] Activation logging failed:', err.message);
+        });
+    }
+
+    // Track decision frame for this standards selection
+    let frameId = null;
+    if (projectId && top.length > 0) {
+        try {
+            const standardIds = top
+                .map(s => s.pattern_id || s.standard_id)
+                .filter(id => id != null);
+            const avgScore = top.reduce((sum, s) => sum + (s.relevance_score || 0), 0) / top.length;
+            const confidence = Math.min(avgScore / 100, 1);
+            const frame = await createFrame({
+                projectId,
+                sessionId: requestBody.sessionId || null,
+                standardIds,
+                confidence,
+                context: { categories, characteristics, total_matched: result.rows.length }
+            });
+            frameId = frame.frame_id;
+        } catch (err) {
+            console.error('[standardsRelevant] Decision frame creation failed:', err.message);
+        }
+    }
+
     return createSuccessResponse({
         standards: top,
         categories,
-        total_matched: result.rows.length
+        total_matched: result.rows.length,
+        frame_id: frameId
     }, 'Relevant standards retrieved');
 }