@equilateral_ai/mindmeld 3.3.1 → 3.4.0

package/src/handlers/reports/engineeringInvestment.js

@@ -20,13 +20,13 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     const period = params.period || '7d';
     const companyId = params.Company_ID;
 
-    // Validate access - must be manager/admin (boolean columns in Tim-Combo schema)
+    // Validate access - must be manager/admin
     const accessCheck = await executeQuery(`
-        SELECT ue."Company_ID"
-        FROM "UserEntitlements" ue
-        WHERE ue."Email_Address" = $1
-        AND (ue."Admin" = true OR ue."Manager" = true)
-        ${companyId ? 'AND ue."Company_ID" = $2' : ''}
+        SELECT ue.company_id
+        FROM rapport.user_entitlements ue
+        WHERE ue.email_address = $1
+        AND (ue.admin = true OR ue.manager = true)
+        ${companyId ? 'AND ue.company_id = $2' : ''}
         LIMIT 1
     `, companyId ? [email, companyId] : [email]);
 
@@ -34,7 +34,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
         return createErrorResponse(403, 'Manager or Admin access required');
     }
 
-    const userCompanyId = companyId || accessCheck.rows[0].Company_ID;
+    const userCompanyId = companyId || accessCheck.rows[0].company_id;
     const periodDays = parsePeriod(period);
     const periodStart = new Date();
     periodStart.setDate(periodStart.getDate() - periodDays);
@@ -43,16 +43,16 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     const investment = await executeQuery(`
         WITH commit_modules AS (
             SELECT
-                COALESCE(SUBSTRING(c.file_path FROM '^([^/]+)'), 'root') as module,
+                c.repo_name as module,
                 COUNT(*) as commit_count,
                 SUM(c.lines_added) as lines_added,
                 SUM(c.lines_removed) as lines_removed,
                 COUNT(DISTINCT c.author_email) as contributors
             FROM rapport.commits c
             JOIN rapport.git_repositories r ON c.repo_id = r.repo_id
-            WHERE r.Company_ID = $1
-            AND c.committed_at >= $2
-            GROUP BY module
+            WHERE r.company_id = $1
+            AND c.commit_timestamp >= $2
+            GROUP BY c.repo_name
         )
         SELECT
             module,
@@ -60,8 +60,8 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             lines_added,
             lines_removed,
             contributors,
-            ROUND(commit_count * 100.0 / SUM(commit_count) OVER (), 1) as commit_percentage,
-            ROUND((lines_added + lines_removed) * 100.0 / SUM(lines_added + lines_removed) OVER (), 1) as churn_percentage
+            ROUND(commit_count * 100.0 / NULLIF(SUM(commit_count) OVER (), 0), 1) as commit_percentage,
+            ROUND((lines_added + lines_removed) * 100.0 / NULLIF(SUM(lines_added + lines_removed) OVER (), 0), 1) as churn_percentage
         FROM commit_modules
         ORDER BY commit_count DESC
         LIMIT 20
@@ -78,7 +78,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             AVG(dm.compliance_score) as avg_compliance
         FROM rapport.developer_metrics dm
         JOIN rapport.git_repositories r ON dm.repo_id = r.repo_id
-        WHERE r.Company_ID = $1
+        WHERE r.company_id = $1
         AND dm.period_start >= $2
         GROUP BY dm.developer_name, dm.developer_email
         ORDER BY total_commits DESC
@@ -93,8 +93,8 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             COUNT(DISTINCT c.author_email) as contributors,
             SUM(c.lines_added) as lines_added
         FROM rapport.git_repositories r
-        LEFT JOIN rapport.commits c ON r.repo_id = c.repo_id AND c.committed_at >= $2
-        WHERE r.Company_ID = $1
+        LEFT JOIN rapport.commits c ON r.repo_id = c.repo_id AND c.commit_timestamp >= $2
+        WHERE r.company_id = $1
         GROUP BY r.repo_id, r.repo_name
         ORDER BY commit_count DESC
     `, [userCompanyId, periodStart]);

package/src/handlers/reports/riskForecast.js

@@ -19,13 +19,13 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     const params = queryStringParameters || {};
     const companyId = params.Company_ID;
 
-    // Validate access - must be manager/admin (boolean columns in Tim-Combo schema)
+    // Validate access - must be manager/admin
     const accessCheck = await executeQuery(`
-        SELECT ue."Company_ID"
-        FROM "UserEntitlements" ue
-        WHERE ue."Email_Address" = $1
-        AND (ue."Admin" = true OR ue."Manager" = true)
-        ${companyId ? 'AND ue."Company_ID" = $2' : ''}
+        SELECT ue.company_id
+        FROM rapport.user_entitlements ue
+        WHERE ue.email_address = $1
+        AND (ue.admin = true OR ue.manager = true)
+        ${companyId ? 'AND ue.company_id = $2' : ''}
         LIMIT 1
     `, companyId ? [email, companyId] : [email]);
 
@@ -33,7 +33,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
         return createErrorResponse(403, 'Manager or Admin access required');
     }
 
-    const userCompanyId = companyId || accessCheck.rows[0].Company_ID;
+    const userCompanyId = companyId || accessCheck.rows[0].company_id;
 
     // Knowledge silos (bus factor analysis)
     let silos = { rows: [] };
@@ -47,7 +47,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 ks.risk_level
             FROM rapport.knowledge_silos ks
             JOIN rapport.git_repositories r ON ks.repo_id = r.repo_id
-            WHERE r."Company_ID" = $1
+            WHERE r.company_id = $1
             ORDER BY
                 CASE ks.risk_level
                     WHEN 'critical' THEN 1
@@ -74,7 +74,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 pr.lines_added + pr.lines_removed as total_changes
             FROM rapport.pull_requests pr
             JOIN rapport.git_repositories r ON pr.repo_id = r.repo_id
-            WHERE r."Company_ID" = $1
+            WHERE r.company_id = $1
             AND pr.status = 'open'
             AND pr.created_at < NOW() - INTERVAL '7 days'
             ORDER BY pr.created_at ASC
@@ -95,7 +95,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 wp.peak_hour
             FROM rapport.working_patterns wp
             JOIN rapport.git_repositories r ON wp.repo_id = r.repo_id
-            WHERE r."Company_ID" = $1
+            WHERE r.company_id = $1
             AND wp.period_start >= NOW() - INTERVAL '30 days'
             GROUP BY wp.developer_email, wp.peak_hour
             HAVING SUM(wp.after_hours_commits) > 10 OR SUM(wp.weekend_commits) > 5
@@ -114,21 +114,41 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
 
     const riskScore = Math.min(100, criticalSilos * 20 + highSilos * 10 + staleCount * 5 + burnoutCount * 5);
 
+    const riskLevel = riskScore >= 70 ? 'critical' : riskScore >= 40 ? 'elevated' : 'normal';
+
     return createSuccessResponse({
         report_type: 'risk_forecast',
         generated_at: new Date().toISOString(),
-        risk_score: {
-            value: riskScore,
-            level: riskScore >= 70 ? 'critical' : riskScore >= 40 ? 'elevated' : 'normal',
-            factors: {
-                knowledge_silos: criticalSilos + highSilos,
-                stale_prs: staleCount,
-                burnout_indicators: burnoutCount
-            }
+        overall_risk_score: riskScore,
+        risk_level: riskLevel,
+        summary: {
+            inactive_developers: 0,
+            high_velocity_devs: burnoutCount,
+            critical_silos: criticalSilos,
+            stale_prs: staleCount,
+            active_alerts: 0,
+            high_churn_files: 0
+        },
+        risks: {
+            knowledge_silos: silos.rows,
+            inactive_developers: [],
+            burnout_risk: burnoutRisk.rows.map(b => ({
+                email: b.developer_email,
+                name: b.developer_email,
+                commits_7d: 0,
+                weekend_commits: parseInt(b.weekend_commits) || 0,
+                after_hours: parseInt(b.after_hours_commits) || 0
+            })),
+            review_bottleneck: stalePRs.rows.map(pr => ({
+                repo: '',
+                pr_number: 0,
+                title: pr.title,
+                author: pr.author_email,
+                days_open: parseInt(pr.days_open) || 0
+            })),
+            high_churn_files: []
         },
-        knowledge_silos: silos.rows,
-        stale_pull_requests: stalePRs.rows,
-        burnout_indicators: burnoutRisk.rows,
+        active_alerts: [],
         recommendations: generateRecommendations(silos.rows, stalePRs.rows, burnoutRisk.rows)
     });
 });

package/src/handlers/reports/standardsRoi.js

@@ -20,13 +20,13 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     const period = params.period || '30d';
     const companyId = params.Company_ID;
 
-    // Validate access - must be manager/admin (boolean columns in Tim-Combo schema)
+    // Validate access - must be manager/admin
     const accessCheck = await executeQuery(`
-        SELECT ue."Company_ID"
-        FROM "UserEntitlements" ue
-        WHERE ue."Email_Address" = $1
-        AND (ue."Admin" = true OR ue."Manager" = true)
-        ${companyId ? 'AND ue."Company_ID" = $2' : ''}
+        SELECT ue.company_id
+        FROM rapport.user_entitlements ue
+        WHERE ue.email_address = $1
+        AND (ue.admin = true OR ue.manager = true)
+        ${companyId ? 'AND ue.company_id = $2' : ''}
         LIMIT 1
     `, companyId ? [email, companyId] : [email]);
 
@@ -34,7 +34,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
         return createErrorResponse(403, 'Manager or Admin access required');
     }
 
-    const userCompanyId = companyId || accessCheck.rows[0].Company_ID;
+    const userCompanyId = companyId || accessCheck.rows[0].company_id;
     const periodDays = parsePeriod(period);
     const periodStart = new Date();
     periodStart.setDate(periodStart.getDate() - periodDays);
@@ -52,7 +52,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 SUM(dm.anti_pattern_commits) as anti_pattern_commits
             FROM rapport.developer_metrics dm
             JOIN rapport.git_repositories r ON dm.repo_id = r.repo_id
-            WHERE r."Company_ID" = $1
+            WHERE r.company_id = $1
             AND dm.period_start >= $2
             GROUP BY dm.developer_email, dm.developer_name
             HAVING SUM(dm.commit_count) > 0
@@ -91,6 +91,95 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     const compliantCommits = complianceData.reduce((sum, r) => sum + parseInt(r.compliant_commits || 0), 0);
     const antiPatternCommits = complianceData.reduce((sum, r) => sum + parseInt(r.anti_pattern_commits || 0), 0);
 
+    // Get standards shown count from session_standards
+    let standardsShown = 0;
+    try {
+        const shownResult = await executeQuery(`
+            SELECT COUNT(*) as total
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND s.started_at >= $2
+        `, [userCompanyId, periodStart]);
+        standardsShown = parseInt(shownResult.rows[0]?.total) || 0;
+    } catch (e) {
+        // Table might not have data
+    }
+
+    // Adoption trend — standards injected per day
+    let adoptionTrend = [];
+    try {
+        const trendResult = await executeQuery(`
+            SELECT
+                DATE(ss.created_at) as date,
+                COUNT(*) as standards_shown,
+                COUNT(DISTINCT ss.session_id) as sessions,
+                COUNT(CASE WHEN ss.followed = true THEN 1 END) as followed,
+                COUNT(CASE WHEN ss.violated = true THEN 1 END) as violated
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND ss.created_at >= $2
+            GROUP BY DATE(ss.created_at)
+            ORDER BY date
+        `, [userCompanyId, periodStart]);
+        adoptionTrend = trendResult.rows;
+    } catch (e) {
+        // Table might not have data
+    }
+
+    // Top standards — most frequently injected
+    let topStandards = [];
+    try {
+        const topResult = await executeQuery(`
+            SELECT
+                ss.standard_id,
+                ss.standard_name,
+                COUNT(*) as times_shown,
+                COUNT(DISTINCT ss.session_id) as unique_sessions,
+                ROUND(AVG(ss.relevance_score), 2) as avg_relevance,
+                COUNT(CASE WHEN ss.followed = true THEN 1 END) as times_followed,
+                COUNT(CASE WHEN ss.violated = true THEN 1 END) as times_violated
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND ss.created_at >= $2
+            GROUP BY ss.standard_id, ss.standard_name
+            ORDER BY times_shown DESC
+            LIMIT 10
+        `, [userCompanyId, periodStart]);
+        topStandards = topResult.rows;
+    } catch (e) {
+        // Table might not have data
+    }
+
+    // Anti-patterns detected — standards that were violated
+    let antiPatternsDetected = [];
+    try {
+        const violationResult = await executeQuery(`
+            SELECT
+                ss.standard_id,
+                ss.standard_name,
+                COUNT(*) as violation_count,
+                MAX(ss.created_at) as last_violated
+            FROM rapport.session_standards ss
+            JOIN rapport.sessions s ON ss.session_id = s.session_id
+            JOIN rapport.projects p ON s.project_id = p.project_id
+            WHERE p.company_id = $1
+            AND ss.created_at >= $2
+            AND ss.violated = true
+            GROUP BY ss.standard_id, ss.standard_name
+            ORDER BY violation_count DESC
+            LIMIT 10
+        `, [userCompanyId, periodStart]);
+        antiPatternsDetected = violationResult.rows;
+    } catch (e) {
+        // Table might not have data
+    }
+
     return createSuccessResponse({
         report_type: 'standards_roi',
         period: period,
@@ -103,9 +192,12 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             compliance_rate: totalCommits > 0 ? ((compliantCommits / totalCommits) * 100).toFixed(1) : '0',
             anti_pattern_commits: antiPatternCommits,
             anti_pattern_rate: totalCommits > 0 ? ((antiPatternCommits / totalCommits) * 100).toFixed(1) : '0',
-            patterns_configured: patterns.rows.length
+            standards_shown: standardsShown
         },
+        adoption_trend: adoptionTrend,
         compliance_by_developer: complianceData,
+        top_standards: topStandards,
+        anti_patterns_detected: antiPatternsDetected,
         configured_patterns: patterns.rows.filter(p => p.pattern_type === 'standard'),
         anti_patterns: patterns.rows.filter(p => p.pattern_type === 'anti_pattern'),
         insights: generateInsights(complianceData)

package/src/handlers/scheduled/maturityUpdateJob.js

@@ -0,0 +1,166 @@
+/**
+ * Maturity Update Scheduled Job
+ * Auto-progresses/demotes standards maturity based on 30-day compliance evidence
+ *
+ * Schedule: Daily
+ * Auth: None (Lambda scheduled event)
+ *
+ * Maturity progression rules (based on session_standards compliance data):
+ * - >90% followed + >50 sessions → enforced
+ * - >70% followed + >20 sessions → validated
+ * - <30% followed + >20 sessions → demote to provisional
+ *
+ * Records all transitions in standards_audit_trail for traceability
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse } = require('./helpers');
+
+/**
+ * Main handler
+ */
+exports.handler = wrapHandler(async (event, context) => {
+    console.log('[MaturityUpdateJob] Starting maturity auto-progression...');
+
+    const lookbackDays = (event && event.lookbackDays) || 30;
+    const dryRun = (event && event.dryRun) || false;
+
+    const summary = {
+        startedAt: new Date().toISOString(),
+        standardsEvaluated: 0,
+        promotions: 0,
+        demotions: 0,
+        unchanged: 0,
+        transitions: [],
+        errors: []
+    };
+
+    try {
+        // Query 30-day compliance rates per standard from session_standards
+        const complianceQuery = `
+            SELECT
+                ss.standard_id,
+                ss.standard_name,
+                COUNT(*) as total_sessions,
+                COUNT(*) FILTER (WHERE ss.followed = true) as followed_count,
+                COUNT(*) FILTER (WHERE ss.violated = true) as violated_count,
+                ROUND(
+                    COUNT(*) FILTER (WHERE ss.followed = true)::decimal /
+                    NULLIF(COUNT(*), 0),
+                    3
+                ) as follow_rate,
+                sp.maturity as current_maturity
+            FROM rapport.session_standards ss
+            LEFT JOIN rapport.standards_patterns sp ON sp.pattern_id = ss.standard_id
+            WHERE ss.shown_at > NOW() - INTERVAL '${lookbackDays} days'
+            GROUP BY ss.standard_id, ss.standard_name, sp.maturity
+            HAVING COUNT(*) >= 10
+            ORDER BY total_sessions DESC
+        `;
+
+        const complianceResult = await executeQuery(complianceQuery);
+        const standards = complianceResult.rows;
+
+        summary.standardsEvaluated = standards.length;
+        console.log(`[MaturityUpdateJob] Evaluating ${standards.length} standards with sufficient data`);
+
+        for (const standard of standards) {
+            const totalSessions = parseInt(standard.total_sessions);
+            const followRate = parseFloat(standard.follow_rate) || 0;
+            const currentMaturity = standard.current_maturity || 'provisional';
+
+            // Determine target maturity
+            let targetMaturity = currentMaturity;
+
+            if (followRate > 0.90 && totalSessions >= 50) {
+                targetMaturity = 'enforced';
+            } else if (followRate > 0.70 && totalSessions >= 20) {
+                targetMaturity = 'validated';
+            } else if (followRate < 0.30 && totalSessions >= 20) {
+                targetMaturity = 'provisional';
+            }
+
+            if (targetMaturity === currentMaturity) {
+                summary.unchanged++;
+                continue;
+            }
+
+            // Determine if this is a promotion or demotion
+            const maturityOrder = { provisional: 0, validated: 1, reinforced: 2, enforced: 3 };
+            const isPromotion = (maturityOrder[targetMaturity] || 0) > (maturityOrder[currentMaturity] || 0);
+
+            const transition = {
+                standard_id: standard.standard_id,
+                standard_name: standard.standard_name,
+                from: currentMaturity,
+                to: targetMaturity,
+                direction: isPromotion ? 'promotion' : 'demotion',
+                follow_rate: followRate,
+                total_sessions: totalSessions
+            };
+
+            summary.transitions.push(transition);
+
+            if (dryRun) {
+                console.log(`[MaturityUpdateJob] DRY RUN: Would ${transition.direction} ${standard.standard_id}: ${currentMaturity} → ${targetMaturity} (${(followRate * 100).toFixed(1)}% followed, ${totalSessions} sessions)`);
+                if (isPromotion) summary.promotions++;
+                else summary.demotions++;
+                continue;
+            }
+
+            try {
+                // Update standards_patterns maturity
+                await executeQuery(`
+                    UPDATE rapport.standards_patterns
+                    SET maturity = $1, last_updated = NOW()
+                    WHERE pattern_id = $2
+                `, [targetMaturity, standard.standard_id]);
+
+                // Record in audit trail
+                await executeQuery(`
+                    INSERT INTO rapport.standards_audit_trail (
+                        standard_id, action, old_state, new_state,
+                        user_email, reason, metadata, created_at
+                    ) VALUES ($1, $2, $3, $4, $5, $6, $7, NOW())
+                `, [
+                    standard.standard_id,
+                    isPromotion ? 'auto_promote' : 'auto_demote',
+                    currentMaturity,
+                    targetMaturity,
+                    'system@mindmeld.dev',
+                    `Auto-${transition.direction}: ${(followRate * 100).toFixed(1)}% follow rate across ${totalSessions} sessions (30-day window)`,
+                    JSON.stringify({
+                        follow_rate: followRate,
+                        total_sessions: totalSessions,
+                        followed_count: parseInt(standard.followed_count),
+                        violated_count: parseInt(standard.violated_count),
+                        lookback_days: lookbackDays
+                    })
+                ]);
+
+                if (isPromotion) summary.promotions++;
+                else summary.demotions++;
+
+                console.log(`[MaturityUpdateJob] ${transition.direction}: ${standard.standard_id} ${currentMaturity} → ${targetMaturity}`);
+
+            } catch (error) {
+                console.error(`[MaturityUpdateJob] Error updating ${standard.standard_id}:`, error.message);
+                summary.errors.push({
+                    standard_id: standard.standard_id,
+                    error: error.message
+                });
+            }
+        }
+
+    } catch (error) {
+        console.error('[MaturityUpdateJob] Job failed:', error);
+        summary.errors.push({ step: 'main', error: error.message });
+    }
+
+    summary.completedAt = new Date().toISOString();
+    console.log(`[MaturityUpdateJob] Complete: ${summary.promotions} promotions, ${summary.demotions} demotions, ${summary.unchanged} unchanged`);
+
+    return createSuccessResponse(
+        summary,
+        `Maturity update complete: ${summary.promotions} promotions, ${summary.demotions} demotions`
+    );
+});

package/src/handlers/sessions/sessionStandardsPost.js

@@ -41,7 +41,7 @@ async function recordSessionStandards({ body: requestBody = {}, requestContext }
         }
 
         // Try to ensure session exists (upsert with minimal data)
-        // This may fail if project_id is not provided or invalid - that's OK
+        // If project doesn't exist, auto-create it to prevent silent session loss
         if (project_id && user_id) {
             const sessionUpsertQuery = `
                 INSERT INTO rapport.sessions (
@@ -59,9 +59,42 @@ async function recordSessionStandards({ body: requestBody = {}, requestContext }
             try {
                 await executeQuery(sessionUpsertQuery, [session_id, project_id, user_id]);
             } catch (sessionError) {
-                // Session insert failed (FK constraint probably)
-                // Continue anyway - we'll try to record standards
-                console.error('[sessionStandardsPost] Session upsert failed:', sessionError.message);
+                // FK constraint on project_id — auto-create the project and retry
+                if (sessionError.code === '23503' && sessionError.constraint && sessionError.constraint.includes('project_id')) {
+                    console.log(`[sessionStandardsPost] Project ${project_id} not found, auto-creating`);
+                    try {
+                        // Look up user's company_id
+                        const entResult = await executeQuery(
+                            `SELECT company_id FROM rapport.user_entitlements WHERE email_address = $1 LIMIT 1`,
+                            [user_id]
+                        );
+                        if (entResult.rowCount > 0) {
+                            const company_id = entResult.rows[0].company_id;
+                            // Derive a readable project name from the project_id
+                            // e.g. prj_pareidolia_main_1770727596802 → pareidolia main
+                            const projectName = project_id
+                                .replace(/^prj_/, '')
+                                .replace(/_\d+$/, '')
+                                .replace(/_/g, ' ');
+
+                            await executeQuery(`
+                                INSERT INTO rapport.projects (project_id, company_id, project_name, private)
+                                VALUES ($1, $2, $3, false)
+                                ON CONFLICT (project_id) DO NOTHING
+                            `, [project_id, company_id, projectName]);
+
+                            // Retry session upsert
+                            await executeQuery(sessionUpsertQuery, [session_id, project_id, user_id]);
+                            console.log(`[sessionStandardsPost] Auto-created project ${project_id} under ${company_id}`);
+                        } else {
+                            console.error(`[sessionStandardsPost] No entitlement found for ${user_id}, cannot auto-create project`);
+                        }
+                    } catch (autoCreateError) {
+                        console.error('[sessionStandardsPost] Auto-create project failed:', autoCreateError.message);
+                    }
+                } else {
+                    console.error('[sessionStandardsPost] Session upsert failed:', sessionError.message);
+                }
             }
         }
 
@@ -71,6 +104,7 @@ async function recordSessionStandards({ body: requestBody = {}, requestContext }
 
         for (const standard of standards) {
             const standardId = standard.pattern_id || standard.element;
+            const standardName = standard.title || standard.element || standardId;
             const relevanceScore = standard.relevance_score || standard.score || 0;
 
             if (!standardId) {
@@ -82,14 +116,15 @@ async function recordSessionStandards({ body: requestBody = {}, requestContext }
                 INSERT INTO rapport.session_standards (
                     session_id,
                     standard_id,
+                    standard_name,
                     relevance_score,
-                    shown_at
+                    created_at
                 ) VALUES (
-                    $1, $2, $3, NOW()
+                    $1, $2, $3, $4, NOW()
                 )
                 ON CONFLICT (session_id, standard_id) DO UPDATE SET
                     relevance_score = EXCLUDED.relevance_score,
-                    shown_at = NOW()
+                    created_at = NOW()
                 RETURNING id
             `;
 
@@ -97,6 +132,7 @@ async function recordSessionStandards({ body: requestBody = {}, requestContext }
                 const result = await executeQuery(insertQuery, [
                     session_id,
                     standardId,
+                    standardName,
                     relevanceScore
                 ]);