@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/src/handlers/standards/discoveriesGet.js

@@ -0,0 +1,93 @@
+/**
+ * Discoveries Get Handler
+ * Returns discovery review queue for a project
+ *
+ * GET /api/standards/discoveries?project_id=xxx&status=proposed
+ * Auth: Cognito JWT required
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
+
+async function getDiscoveries({ queryStringParameters, requestContext }) {
+    try {
+        const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
+
+        if (!email) {
+            return createErrorResponse(401, 'Authentication required');
+        }
+
+        const projectId = (queryStringParameters || {}).project_id;
+        const status = (queryStringParameters || {}).status;
+
+        if (!projectId) {
+            return createErrorResponse(400, 'project_id is required');
+        }
+
+        // Verify user has access to project
+        const accessResult = await executeQuery(`
+            SELECT role FROM rapport.project_collaborators
+            WHERE project_id = $1 AND email_address = $2
+        `, [projectId, email]);
+
+        if (accessResult.rowCount === 0) {
+            return createErrorResponse(403, 'Access denied to project');
+        }
+
+        // Build query with optional status filter
+        let query = `
+            SELECT
+                discovery_id,
+                project_id,
+                pattern_name,
+                pattern_description,
+                confidence,
+                discovery_type,
+                status,
+                evidence,
+                reason,
+                reason_code,
+                created_at,
+                updated_at
+            FROM rapport.onboarding_discoveries
+            WHERE project_id = $1
+        `;
+        const params = [projectId];
+
+        if (status) {
+            query += ` AND status = $2`;
+            params.push(status);
+        }
+
+        query += ` ORDER BY confidence DESC, created_at DESC`;
+
+        const result = await executeQuery(query, params);
+
+        // Map DB columns to frontend Discovery interface
+        const records = result.rows.map(row => ({
+            id: row.discovery_id,
+            project_id: row.project_id,
+            name: row.pattern_name,
+            description: row.pattern_description || '',
+            confidence: parseFloat(row.confidence) || 0,
+            source: 'github',
+            category: row.discovery_type || 'Architecture',
+            status: row.status || 'proposed',
+            rule_text: null,
+            action_type: null,
+            evidence: row.evidence || null,
+            created_at: row.created_at,
+            updated_at: row.updated_at
+        }));
+
+        return createSuccessResponse({
+            records,
+            total: result.rowCount
+        }, `Found ${result.rowCount} discoveries`);
+
+    } catch (error) {
+        console.error('Discoveries Get Error:', error);
+        return createErrorResponse(500, 'Failed to load discoveries');
+    }
+}
+
+exports.handler = wrapHandler(getDiscoveries);

package/src/handlers/standards/projectStandardsGet.js

@@ -8,7 +8,7 @@
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
 
-async function getProjectStandards({ queryStringParameters, requestContext }) {
+async function getProjectStandards({ queryStringParameters, pathParameters, requestContext }) {
     try {
         const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
 
@@ -16,7 +16,7 @@ async function getProjectStandards({ queryStringParameters, requestContext }) {
             return createErrorResponse(401, 'Authentication required');
         }
 
-        const projectId = (queryStringParameters || {}).project_id;
+        const projectId = pathParameters?.projectId || (queryStringParameters || {}).project_id;
 
         if (!projectId) {
             return createErrorResponse(400, 'projectId is required');

package/src/handlers/standards/projectStandardsPut.js

@@ -9,7 +9,7 @@
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
 
-async function updateProjectStandards({ body, requestContext }) {
+async function updateProjectStandards({ body, pathParameters, requestContext }) {
     try {
         const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
 
@@ -17,7 +17,7 @@ async function updateProjectStandards({ body, requestContext }) {
             return createErrorResponse(401, 'Authentication required');
         }
 
-        const projectId = (body || {}).project_id;
+        const projectId = pathParameters?.projectId || (body || {}).project_id;
 
         if (!projectId) {
             return createErrorResponse(400, 'projectId is required');

package/src/handlers/standards/standardsRelevantPost.js

@@ -18,15 +18,16 @@ const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse }
  */
 const CATEGORY_WEIGHTS = {
     'serverless-saas-aws': 1.0,
-    'multi-agent-orchestration': 1.0,
     'frontend-development': 1.0,
     'database': 0.9,
-    'compliance-security': 0.8,
-    'cost-optimization': 0.7,
-    'real-time-systems': 0.8,
-    'testing': 0.6,
     'backend': 0.9,
-    'well-architected': 0.7
+    'compliance-security': 0.9,
+    'deployment': 0.8,
+    'testing': 0.7,
+    'real-time-systems': 0.7,
+    'well-architected': 0.7,
+    'cost-optimization': 0.7,
+    'multi-agent-orchestration': 0.1,  // Infrastructure config, rarely needed in coding sessions
 };
 
 /**
@@ -54,6 +55,9 @@ function mapCharacteristicsToCategories(characteristics) {
     if (characteristics.hasTests) {
         categories.add('testing');
     }
+    if (characteristics.hasSAM || characteristics.hasLambda || characteristics.hasAPI) {
+        categories.add('deployment');
+    }
 
     // Always relevant
     categories.add('compliance-security');
@@ -65,7 +69,7 @@ function mapCharacteristicsToCategories(characteristics) {
 /**
  * Rank standards by relevance score
  */
-function rankStandards(standards) {
+function rankStandards(standards, recentCategories) {
     return standards.map(standard => {
         let score = 0;
 
@@ -98,6 +102,23 @@ function rankStandards(standards) {
             if (apCount > 0) score += 5;
         }
 
+        // Workflow bonus — workflows are high-value procedural knowledge
+        const isWorkflow = (standard.rule && standard.rule.startsWith('WORKFLOW:'))
+            || (Array.isArray(standard.keywords) && standard.keywords.includes('workflow'));
+        if (isWorkflow) score += 10;
+
+        // 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)
+        if (recentCategories && recentCategories[standard.category]) {
+            const usageCount = recentCategories[standard.category];
+            let rawBonus;
+            if (usageCount >= 8) rawBonus = 25;
+            else if (usageCount >= 4) rawBonus = 18;
+            else rawBonus = 10;
+            score += rawBonus * categoryWeight;
+        }
+
         return {
             ...standard,
             relevance_score: Math.round(score * 10) / 10
@@ -141,6 +162,25 @@ async function getRelevantStandards({ body, requestContext }) {
         return createErrorResponse(401, 'Authentication required');
     }
 
+    // Verify active subscription — no free tier access
+    const subResult = await executeQuery(`
+        SELECT c.subscription_tier, c.subscription_status
+        FROM rapport.users u
+        JOIN rapport.clients c ON u.client_id = c.client_id
+        WHERE u.email_address = $1
+        LIMIT 1
+    `, [email]);
+
+    if (subResult.rows.length > 0) {
+        const { subscription_tier, subscription_status } = subResult.rows[0];
+        if (!subscription_tier || subscription_tier === 'free') {
+            return createErrorResponse(403, 'Active MindMeld subscription required. Subscribe at app.mindmeld.dev');
+        }
+        if (subscription_status === 'canceled') {
+            return createErrorResponse(403, 'Subscription canceled. Resubscribe at app.mindmeld.dev');
+        }
+    }
+
     // Parse request body
     let requestBody;
     try {
@@ -166,13 +206,43 @@ async function getRelevantStandards({ body, requestContext }) {
         }, 'No relevant categories detected');
     }
 
-    // Query standards matching categories
+    // Query recent session categories first (fast), then merge into categories for main query
+    const recentCategories = {};
+    try {
+        const recencyResult = await executeQuery(`
+            SELECT sp.category, COUNT(*) as usage_count
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON s.session_id = ss.session_id
+            JOIN rapport.standards_patterns sp ON sp.pattern_id = ss.standard_id
+            WHERE s.email_address = $1
+                AND s.started_at >= NOW() - INTERVAL '7 days'
+            GROUP BY sp.category
+            ORDER BY usage_count DESC
+            LIMIT 5
+        `, [email]);
+        for (const row of recencyResult.rows) {
+            recentCategories[row.category] = parseInt(row.usage_count, 10);
+        }
+    } catch (err) {
+        console.error('[standardsRelevant] Recency query failed:', err.message);
+    }
+
+    // Merge recency categories into query — recent activity should always be represented
+    for (const category of Object.keys(recentCategories)) {
+        if (!categories.includes(category)) {
+            categories.push(category);
+        }
+    }
+
+    // Query standards from all relevant categories (static + recency)
     const result = await executeQuery(`
         SELECT
             pattern_id,
             element,
+            title,
             rule,
             category,
+            keywords,
             correlation,
             maturity,
             applicable_files,
@@ -192,16 +262,41 @@ async function getRelevantStandards({ body, requestContext }) {
             correlation DESC
     `, [categories]);
 
-    // Rank by relevance
-    let ranked = rankStandards(result.rows);
+    // Rank by relevance with recency boost
+    let ranked = rankStandards(result.rows, recentCategories);
+
+    // Deduplicate by element name (same rule can be ingested with different path prefixes)
+    const seenElements = new Set();
+    ranked = ranked.filter(standard => {
+        const key = standard.element;
+        if (seenElements.has(key)) return false;
+        seenElements.add(key);
+        return true;
+    });
 
     // Apply preferences if provided
     if (preferences) {
         ranked = applyPreferences(ranked, preferences);
     }
 
-    // Return top 10
-    const top = ranked.slice(0, 10);
+    // 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)
+    const MAX_PER_CATEGORY = 2;
+    const MAX_PER_TITLE = 1;
+    const top = [];
+    const categoryCounts = {};
+    const titleCounts = {};
+    for (const standard of ranked) {
+        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);
+            if (top.length >= 10) break;
+        }
+    }
 
     return createSuccessResponse({
         standards: top,

package/src/handlers/standards/standardsTransition.js

@@ -1,17 +1,95 @@
 /**
  * Standards Transition Handler
- * Executes lifecycle state transitions on standards
+ * Executes lifecycle state transitions on standards and discoveries
  *
  * POST /api/standards/transition
- * Body: { standard_id, action: 'approve'|'disable'|'deprecate'|'delete'|'enable'|'cancel_deprecation', reason? }
+ * Body: { standard_id, action: 'approve'|'reject'|'observe'|'disable'|'deprecate'|'delete'|'enable'|'cancel_deprecation', reason?, reason_code? }
  * Auth: Cognito JWT required
+ *
+ * For discovery IDs (from onboarding_discoveries table):
+ *   approve  → creates pattern + marks discovery approved
+ *   reject   → marks discovery rejected
+ *   observe  → marks discovery as observing (deferred review)
  */
 
-const { wrapHandler, createSuccessResponse, createErrorResponse } = require('./helpers');
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse } = require('./helpers');
 const { StandardLifecycle } = require('./core/StandardLifecycle');
 
 const lifecycle = new StandardLifecycle();
 
+const DISCOVERY_ACTIONS = ['approve', 'reject', 'observe'];
+
+/**
+ * Handle transitions for onboarding discoveries
+ */
+async function transitionDiscovery(discoveryId, action, email, reason, reasonCode) {
+    const discovery = await executeQuery(`
+        SELECT discovery_id, project_id, discovery_type, pattern_name, pattern_description, confidence, evidence, status
+        FROM rapport.onboarding_discoveries
+        WHERE discovery_id = $1
+    `, [discoveryId]);
+
+    if (discovery.rowCount === 0) {
+        return null; // Not a discovery either
+    }
+
+    const row = discovery.rows[0];
+    const oldStatus = row.status;
+
+    if (action === 'approve') {
+        // Create pattern from discovery
+        const patternId = `pat_${row.project_id}_${Date.now()}`;
+        await executeQuery(`
+            INSERT INTO rapport.patterns (
+                pattern_id, project_id, intent, constraints, outcome_criteria,
+                maturity, discovered_by, pattern_data
+            ) VALUES ($1, $2, $3, $4, $5, 'provisional', $6, $7)
+        `, [
+            patternId,
+            row.project_id,
+            row.pattern_name,
+            JSON.stringify([row.pattern_description || '']),
+            JSON.stringify([`Discovered via onboarding: ${row.discovery_type}`]),
+            email,
+            JSON.stringify({
+                source: 'discovery_review',
+                discovery_type: row.discovery_type,
+                evidence: row.evidence
+            })
+        ]);
+
+        await executeQuery(`
+            UPDATE rapport.onboarding_discoveries
+            SET status = 'approved', reviewed_at = NOW(), updated_at = NOW(), pattern_id = $1
+            WHERE discovery_id = $2
+        `, [patternId, discoveryId]);
+
+        return { old_state: oldStatus, new_state: 'approved', pattern_id: patternId };
+    }
+
+    if (action === 'reject') {
+        await executeQuery(`
+            UPDATE rapport.onboarding_discoveries
+            SET status = 'rejected', reviewed_at = NOW(), updated_at = NOW(), reason = $1, reason_code = $2
+            WHERE discovery_id = $3
+        `, [reason || null, reasonCode || null, discoveryId]);
+
+        return { old_state: oldStatus, new_state: 'rejected' };
+    }
+
+    if (action === 'observe') {
+        await executeQuery(`
+            UPDATE rapport.onboarding_discoveries
+            SET status = 'observing', updated_at = NOW()
+            WHERE discovery_id = $1
+        `, [discoveryId]);
+
+        return { old_state: oldStatus, new_state: 'observing' };
+    }
+
+    return null;
+}
+
 async function transitionStandard({ body, requestContext }) {
     try {
         const email = requestContext.authorizer?.claims?.email || requestContext.authorizer?.jwt?.claims?.email;
@@ -20,7 +98,7 @@ async function transitionStandard({ body, requestContext }) {
             return createErrorResponse(401, 'Authentication required');
         }
 
-        const { standard_id: id, action, reason } = body || {};
+        const { standard_id: id, action, reason, reason_code: reasonCode } = body || {};
 
         if (!id) {
             return createErrorResponse(400, 'standard_id is required');
@@ -28,25 +106,44 @@ async function transitionStandard({ body, requestContext }) {
 
         if (!action) {
             return createErrorResponse(400, 'action is required', {
-                valid_actions: ['propose', 'approve', 'reject', 'disable', 'deprecate', 'delete', 'enable', 'cancel_deprecation']
+                valid_actions: ['propose', 'approve', 'reject', 'observe', 'disable', 'deprecate', 'delete', 'enable', 'cancel_deprecation']
             });
         }
 
-        // Execute the transition
-        const result = await lifecycle.transition(id, action, email, reason);
+        // Try standard lifecycle transition first
+        try {
+            const result = await lifecycle.transition(id, action, email, reason);
+
+            return createSuccessResponse({
+                standard_id: result.standard_id,
+                old_state: result.old_state,
+                new_state: result.new_state,
+                action: result.action,
+                audit_entry: result.audit_entry
+            }, `Standard transitioned from '${result.old_state}' to '${result.new_state}'`);
+        } catch (lifecycleError) {
+            // If pattern not found and action is valid for discoveries, try discovery transition
+            if (lifecycleError.message.includes('not found') && DISCOVERY_ACTIONS.includes(action)) {
+                const discoveryResult = await transitionDiscovery(id, action, email, reason, reasonCode);
 
-        return createSuccessResponse({
-            standard_id: result.standard_id,
-            old_state: result.old_state,
-            new_state: result.new_state,
-            action: result.action,
-            audit_entry: result.audit_entry
-        }, `Standard transitioned from '${result.old_state}' to '${result.new_state}'`);
+                if (discoveryResult) {
+                    return createSuccessResponse({
+                        standard_id: id,
+                        old_state: discoveryResult.old_state,
+                        new_state: discoveryResult.new_state,
+                        action,
+                        pattern_id: discoveryResult.pattern_id || null
+                    }, `Discovery transitioned from '${discoveryResult.old_state}' to '${discoveryResult.new_state}'`);
+                }
+            }
+
+            // Re-throw if not handled
+            throw lifecycleError;
+        }
 
     } catch (error) {
         console.error('Standards Transition Error:', error);
 
-        // Return user-friendly messages for known validation errors
         if (error.message.includes('Invalid action')) {
             return createErrorResponse(400, error.message);
         }

package/src/handlers/stripe/billingPortalPost.js

@@ -67,7 +67,7 @@ async function createBillingPortal({ body: requestBody = {}, requestContext }) {
         // Create billing portal session
         const session = await stripe.billingPortal.sessions.create({
             customer: client.stripe_customer_id,
-            return_url: returnUrl || `${process.env.APP_URL || 'https://mindmeld.dev'}/settings/billing`
+            return_url: returnUrl || `${process.env.APP_URL || 'https://app.mindmeld.dev'}/settings/billing`
         });
 
         return createSuccessResponse(

package/src/handlers/stripe/enterpriseCheckoutPost.js

@@ -159,8 +159,8 @@ async function createEnterpriseCheckout({ body: requestBody = {}, requestContext
             payment_method_types: ['card'],
             customer_email: email,
             line_items: lineItems,
-            success_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/enterprise/success?session_id={CHECKOUT_SESSION_ID}`,
-            cancel_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/enterprise/cancel`,
+            success_url: `${process.env.APP_URL || 'https://app.mindmeld.dev'}/enterprise/success?session_id={CHECKOUT_SESSION_ID}`,
+            cancel_url: `${process.env.APP_URL || 'https://app.mindmeld.dev'}/enterprise/cancel`,
             metadata: {
                 client_id: user.client_id,
                 user_email: email,

package/src/handlers/stripe/subscriptionCreatePost.js

@@ -118,8 +118,8 @@ async function createSubscription({ body: requestBody = {}, requestContext }) {
                 price: priceId,
                 quantity: tierConfig.perUser ? userCount : 1
             }],
-            success_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/subscription/success?session_id={CHECKOUT_SESSION_ID}`,
-            cancel_url: `${process.env.APP_URL || 'https://mindmeld.dev'}/subscription/cancel`,
+            success_url: `${process.env.APP_URL || 'https://app.mindmeld.dev'}/dashboard?checkout=success`,
+            cancel_url: `${process.env.APP_URL || 'https://app.mindmeld.dev'}/signup`,
             metadata: {
                 client_id: user.client_id,
                 user_email: email,

package/src/handlers/stripe/webhookPost.js

@@ -72,18 +72,22 @@ async function handleCheckoutCompleted(session) {
     const { client_id, tier, user_email, enterprise_package, seat_count, addons } = session.metadata || {};
 
     if (!client_id) {
-        console.warn('Missing client_id in session metadata');
-        return;
+        console.error('[webhookPost] CRITICAL: Missing client_id in checkout session metadata — subscription will not activate');
+        throw new Error('Missing client_id in checkout session metadata');
     }
 
     // Parse enterprise metadata
     const isEnterprise = tier === 'enterprise';
     const seatCountNum = seat_count ? parseInt(seat_count, 10) : 1;
-    const addonsList = addons ? JSON.parse(addons) : [];
+    let addonsList = [];
+    if (addons) {
+        try { addonsList = JSON.parse(addons); }
+        catch { console.warn('Failed to parse addons metadata:', addons); }
+    }
 
     // Update client with subscription
     if (isEnterprise) {
-        await executeQuery(`
+        const updateResult = await executeQuery(`
             UPDATE rapport.clients
             SET stripe_customer_id = $2,
                 stripe_subscription_id = $3,
@@ -96,6 +100,11 @@ async function handleCheckoutCompleted(session) {
             WHERE client_id = $1
         `, [client_id, session.customer, session.subscription, enterprise_package, seatCountNum, JSON.stringify(addonsList)]);
 
+        if (updateResult.rowCount === 0) {
+            console.error(`[webhookPost] CRITICAL: Client ${client_id} not found in DB — subscription paid but not activated`);
+            throw new Error(`Client ${client_id} not found — subscription activation failed`);
+        }
+
         // Create addon entitlements if any
         if (addonsList.length > 0) {
             for (const addonId of addonsList) {
@@ -112,7 +121,7 @@ async function handleCheckoutCompleted(session) {
 
         console.log('Enterprise checkout completed:', { client_id, enterprise_package, seat_count: seatCountNum, addons: addonsList });
     } else {
-        await executeQuery(`
+        const updateResult = await executeQuery(`
             UPDATE rapport.clients
             SET stripe_customer_id = $2,
                 stripe_subscription_id = $3,
@@ -122,6 +131,11 @@ async function handleCheckoutCompleted(session) {
             WHERE client_id = $1
         `, [client_id, session.customer, session.subscription, tier || 'team']);
 
+        if (updateResult.rowCount === 0) {
+            console.error(`[webhookPost] CRITICAL: Client ${client_id} not found in DB — subscription paid but not activated`);
+            throw new Error(`Client ${client_id} not found — subscription activation failed`);
+        }
+
         console.log('Checkout completed:', { client_id, tier, customer: session.customer });
     }
 
@@ -160,7 +174,11 @@ async function handleSubscriptionUpdated(subscription) {
     // Parse enterprise metadata
     const isEnterprise = tier === 'enterprise';
     const seatCountNum = seat_count ? parseInt(seat_count, 10) : null;
-    const addonsList = addons ? JSON.parse(addons) : null;
+    let addonsList = null;
+    if (addons) {
+        try { addonsList = JSON.parse(addons); }
+        catch { console.warn('Failed to parse addons metadata in subscription update:', addons); }
+    }
 
     // Build update query based on what changed
     if (isEnterprise) {
@@ -424,15 +442,25 @@ async function handler(event, context) {
             console.error('Error processing webhook:', processError);
 
             // Record error
-            await executeQuery(`
-                UPDATE rapport.stripe_webhook_events
-                SET handled = false,
-                    error = $2,
-                    processed_at = CURRENT_TIMESTAMP
-                WHERE event_id = $1
-            `, [stripeEvent.id, processError.message]);
+            try {
+                await executeQuery(`
+                    UPDATE rapport.stripe_webhook_events
+                    SET handled = false,
+                        error = $2,
+                        processed_at = CURRENT_TIMESTAMP
+                    WHERE event_id = $1
+                `, [stripeEvent.id, processError.message]);
+            } catch (recordErr) {
+                console.error('Failed to record webhook error:', recordErr.message);
+            }
 
-            // Still return 200 to prevent Stripe retries for business logic errors
+            // Return 500 for critical failures so Stripe retries
+            // (missing client, DB connection errors, subscription not activated)
+            return {
+                statusCode: 500,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ error: processError.message })
+            };
         }
 
         return {