@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/src/handlers/notifications/sendNotification.js

@@ -52,13 +52,13 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     // Check authorization (only admins and managers can send notifications)
     const authCheck = await executeQuery(`
         SELECT
-            ue."Admin",
-            ue."Manager",
-            u."Super_Admin",
-            ue."Company_ID"
-        FROM "UserEntitlements" ue
-        JOIN "Users" u ON ue."Email_Address" = u."Email_Address"
-        WHERE ue."Email_Address" = $1
+            ue.admin,
+            ue.manager,
+            u.super_admin,
+            ue.company_id
+        FROM rapport.user_entitlements ue
+        JOIN rapport.users u ON ue.email_address = u.email_address
+        WHERE ue.email_address = $1
     `, [email]);
 
     if (authCheck.rowCount === 0) {
@@ -66,7 +66,7 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     }
 
     const userRole = authCheck.rows[0];
-    const isAuthorized = userRole.Super_Admin || userRole.Admin || userRole.Manager;
+    const isAuthorized = userRole.super_admin || userRole.admin || userRole.manager;
 
     if (!isAuthorized) {
         return createErrorResponse(403, 'Only admins and managers can send notifications');
@@ -89,18 +89,18 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     } else if (recipients === 'all_admins') {
         // All company admins
         const admins = await executeQuery(`
-            SELECT ue."Email_Address" as email_address
-            FROM "UserEntitlements" ue
-            WHERE ue."Company_ID" = $1 AND ue."Admin" = true
-        `, [userRole.Company_ID]);
+            SELECT ue.email_address
+            FROM rapport.user_entitlements ue
+            WHERE ue.company_id = $1 AND ue.admin = true
+        `, [userRole.company_id]);
         recipientEmails = admins.rows.map(r => r.email_address);
     } else if (recipients === 'all_managers') {
         // All company managers
         const managers = await executeQuery(`
-            SELECT ue."Email_Address" as email_address
-            FROM "UserEntitlements" ue
-            WHERE ue."Company_ID" = $1 AND (ue."Manager" = true OR ue."Admin" = true)
-        `, [userRole.Company_ID]);
+            SELECT ue.email_address
+            FROM rapport.user_entitlements ue
+            WHERE ue.company_id = $1 AND (ue.manager = true OR ue.admin = true)
+        `, [userRole.company_id]);
         recipientEmails = managers.rows.map(r => r.email_address);
     } else {
         return createErrorResponse(400, 'Invalid recipients format');
@@ -118,8 +118,8 @@ exports.handler = wrapHandler(async ({ requestContext, body }) => {
     // Get preferences for all recipients
     const prefsQuery = await executeQuery(`
         SELECT email_address, rapport.get_notification_preferences(email_address) as preferences
-        FROM "Users"
-        WHERE "Email_Address" = ANY($1)
+        FROM rapport.users
+        WHERE email_address = ANY($1)
     `, [recipientEmails]);
 
     const prefsMap = new Map(prefsQuery.rows.map(r => [r.email_address, r.preferences]));

package/src/handlers/patterns/patternEvaluatePromotionPost.js

@@ -0,0 +1,173 @@
+/**
+ * Pattern Evaluate Promotion Handler
+ * Checks if a pattern meets promotion thresholds for becoming a standard
+ *
+ * POST /api/patterns/evaluate-promotion
+ * Body: { pattern, project_id, evaluate_only }
+ *
+ * Called by: pre-compact.js hook (evaluateForPromotion method)
+ *
+ * Promotion Criteria:
+ * - handoff_count >= 10 (used 10+ times)
+ * - success_rate >= 0.70 (70% success)
+ * - developer_count >= 3 (used by 3+ developers)
+ */
+
+const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError } = require('./helpers');
+
+/**
+ * Evaluate pattern for promotion to standard
+ */
+async function evaluatePatternPromotion({ body: requestBody = {}, requestContext }) {
+    try {
+        const Request_ID = requestContext?.requestId || 'unknown';
+
+        const {
+            pattern,
+            project_id,
+            evaluate_only = true
+        } = requestBody;
+
+        // Validate required fields
+        if (!pattern || !pattern.element) {
+            return createErrorResponse(400, 'pattern.element is required');
+        }
+
+        // Generate pattern_id from element
+        const patternId = pattern.pattern_id || `pat_${pattern.element.toLowerCase().replace(/\s+/g, '_').substring(0, 50)}`;
+
+        // Look up pattern in rapport.patterns
+        const patternQuery = `
+            SELECT
+                p.pattern_id,
+                p.intent,
+                p.maturity,
+                p.handoff_count,
+                p.successful_handoffs,
+                p.failed_handoffs,
+                p.discovered_at,
+                p.last_used
+            FROM rapport.patterns p
+            WHERE p.pattern_id = $1
+        `;
+
+        const patternResult = await executeQuery(patternQuery, [patternId]);
+
+        if (patternResult.rows.length === 0) {
+            return createSuccessResponse(
+                {
+                    Records: [{
+                        pattern_id: patternId,
+                        eligible: false,
+                        reason: 'not_found',
+                        message: 'Pattern not found in patterns table'
+                    }]
+                },
+                'Pattern not found',
+                { Total_Records: 0, Request_ID, Timestamp: new Date().toISOString() }
+            );
+        }
+
+        const pat = patternResult.rows[0];
+
+        // Query usage metrics
+        const metricsQuery = `
+            SELECT
+                COUNT(DISTINCT pu.email_address) as developer_count,
+                COUNT(DISTINCT pu.session_id) as session_count,
+                COUNT(*) FILTER (WHERE pu.success = true) as successes,
+                COUNT(*) as total_uses
+            FROM rapport.pattern_usage pu
+            WHERE pu.pattern_id = $1
+        `;
+
+        const metricsResult = await executeQuery(metricsQuery, [patternId]);
+        const metrics = metricsResult.rows[0];
+
+        const handoffCount = parseInt(pat.handoff_count) || 0;
+        const successRate = handoffCount > 0
+            ? (parseInt(pat.successful_handoffs) || 0) / handoffCount
+            : 0;
+        const developerCount = parseInt(metrics.developer_count) || 0;
+        const sessionCount = parseInt(metrics.session_count) || 0;
+
+        // Check promotion thresholds
+        const eligible =
+            handoffCount >= 10 &&
+            successRate >= 0.70 &&
+            developerCount >= 3;
+
+        const response = {
+            pattern_id: patternId,
+            eligible: eligible,
+            metrics: {
+                handoff_count: handoffCount,
+                success_rate: parseFloat(successRate.toFixed(3)),
+                developer_count: developerCount,
+                session_count: sessionCount,
+                maturity: pat.maturity,
+                success_correlation: parseFloat(successRate.toFixed(3))
+            },
+            thresholds: {
+                min_handoffs: 10,
+                min_success_rate: 0.70,
+                min_developers: 3
+            },
+            proposed_category: pattern.category || null
+        };
+
+        // If eligible and not evaluate_only, create curation candidate
+        if (eligible && !evaluate_only) {
+            const candidateQuery = `
+                INSERT INTO rapport.curation_candidates (
+                    pattern_id,
+                    proposed_category,
+                    evidence,
+                    status,
+                    created_at
+                ) VALUES ($1, $2, $3, 'pending', NOW())
+                ON CONFLICT (pattern_id) WHERE status = 'pending'
+                DO UPDATE SET
+                    evidence = EXCLUDED.evidence,
+                    created_at = NOW()
+                RETURNING candidate_id
+            `;
+
+            const evidence = {
+                handoff_count: handoffCount,
+                success_rate: successRate,
+                developer_count: developerCount,
+                session_count: sessionCount,
+                maturity: pat.maturity,
+                evaluated_at: new Date().toISOString()
+            };
+
+            try {
+                const candidateResult = await executeQuery(candidateQuery, [
+                    patternId,
+                    pattern.category || 'uncategorized',
+                    JSON.stringify(evidence)
+                ]);
+
+                if (candidateResult.rows.length > 0) {
+                    response.candidate_id = candidateResult.rows[0].candidate_id;
+                }
+            } catch (candidateError) {
+                // Candidate creation failed — still return eligibility result
+                console.error('[patternEvaluatePromotionPost] Candidate creation failed:', candidateError.message);
+            }
+        }
+
+        return createSuccessResponse(
+            { Records: [response] },
+            eligible ? 'Pattern eligible for promotion' : 'Pattern does not meet promotion criteria',
+            { Total_Records: 1, Request_ID, Timestamp: new Date().toISOString() }
+        );
+
+    } catch (error) {
+        console.error('Handler Error:', error);
+        return handleError(error);
+    }
+}
+
+exports.handler = wrapHandler(evaluatePatternPromotion);

package/src/handlers/projects/projectCreate.js

@@ -7,6 +7,8 @@
  */
 
 const { wrapHandler, executeQuery, createSuccessResponse, createErrorResponse, handleError, checkSubscriptionLimits } = require('./helpers');
+const crypto = require('crypto');
+const https = require('https');
 
 /**
  * Create project
@@ -27,24 +29,24 @@ async function createProject({ body: requestBody = {}, requestContext }) {
 
         // Check user has admin access to company
         const adminQuery = `
-            SELECT ue."Admin", c."Company_Name"
-            FROM "UserEntitlements" ue
-            JOIN "Company" c ON ue."Company_ID" = c."Company_ID"
-            WHERE ue."Email_Address" = $1
-            AND ue."Company_ID" = $2
+            SELECT ue.admin, c.company_name
+            FROM rapport.user_entitlements ue
+            JOIN rapport.companies c ON ue.company_id = c.company_id
+            WHERE ue.email_address = $1
+            AND ue.company_id = $2
         `;
         const adminCheck = await executeQuery(adminQuery, [email, Company_ID]);
 
-        if (adminCheck.rowCount === 0 || !adminCheck.rows[0].Admin) {
+        if (adminCheck.rowCount === 0 || !adminCheck.rows[0].admin) {
             return createErrorResponse(403, 'Admin access required to create projects');
         }
 
         // Check project limit for subscription tier
         const clientQuery = `
             SELECT c.subscription_tier
-            FROM "Client" c
-            JOIN "UserEntitlements" ue ON c."Client_ID" = ue."Client_ID"
-            WHERE ue."Email_Address" = $1 AND ue."Company_ID" = $2
+            FROM rapport.clients c
+            JOIN rapport.user_entitlements ue ON c.client_id = ue.client_id
+            WHERE ue.email_address = $1 AND ue.company_id = $2
         `;
         const clientResult = await executeQuery(clientQuery, [email, Company_ID]);
         const subscriptionTier = clientResult.rows[0]?.subscription_tier || 'free';
@@ -112,8 +114,18 @@ async function createProject({ body: requestBody = {}, requestContext }) {
         `;
         await executeQuery(collabQuery, [project_id, email]);
 
+        // Auto-create GitHub webhook if repo_url is a GitHub URL
+        let webhookCreated = false;
+        if (repo_url && repo_url.includes('github.com')) {
+            try {
+                webhookCreated = await createGitHubWebhook(email, repo_url, Company_ID);
+            } catch (webhookErr) {
+                console.warn('Webhook creation failed (non-blocking):', webhookErr.message);
+            }
+        }
+
         return createSuccessResponse(
-            { Records: result.rows },
+            { Records: result.rows, webhook_created: webhookCreated },
             'Project created successfully',
             {
                 Total_Records: result.rowCount,
@@ -131,4 +143,106 @@ async function createProject({ body: requestBody = {}, requestContext }) {
     }
 }
 
+/**
+ * Create GitHub webhook on a repo when a project is connected
+ * Uses the customer's stored GitHub OAuth token and a per-repo secret
+ */
+async function createGitHubWebhook(email, repoUrl, companyId) {
+    // Extract owner/repo from URL
+    const match = repoUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (!match) {
+        console.log('Could not parse GitHub owner/repo from:', repoUrl);
+        return false;
+    }
+    const [, owner, repo] = match;
+
+    // Get the user's GitHub token
+    const connResult = await executeQuery(`
+        SELECT access_token_encrypted FROM rapport.github_connections
+        WHERE email_address = $1 AND revoked = FALSE
+    `, [email]);
+
+    if (connResult.rowCount === 0) {
+        console.log('No GitHub connection for', email);
+        return false;
+    }
+
+    const encryptionKey = process.env.GITHUB_TOKEN_ENCRYPTION_KEY;
+    if (!encryptionKey) return false;
+
+    const accessToken = decryptToken(connResult.rows[0].access_token_encrypted, encryptionKey);
+
+    // Generate per-repo webhook secret
+    const webhookSecret = crypto.randomBytes(32).toString('hex');
+    const webhookUrl = process.env.WEBHOOK_URL || 'https://api.mindmeld.dev/api/webhooks/github';
+
+    // Create webhook via GitHub API
+    const payload = JSON.stringify({
+        name: 'web',
+        active: true,
+        events: ['push', 'pull_request'],
+        config: {
+            url: webhookUrl,
+            content_type: 'json',
+            secret: webhookSecret,
+            insecure_ssl: '0'
+        }
+    });
+
+    const response = await new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'api.github.com',
+            path: `/repos/${owner}/${repo}/hooks`,
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'User-Agent': 'MindMeld-App',
+                'Accept': 'application/vnd.github+json',
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload)
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try { resolve({ statusCode: res.statusCode, body: JSON.parse(data) }); }
+                catch (e) { resolve({ statusCode: res.statusCode, body: data }); }
+            });
+        });
+        req.on('error', reject);
+        req.write(payload);
+        req.end();
+    });
+
+    if (response.statusCode !== 201) {
+        console.warn(`GitHub webhook creation returned ${response.statusCode}:`, JSON.stringify(response.body).substring(0, 200));
+        return false;
+    }
+
+    const githubWebhookId = response.body.id;
+
+    // Register repo in git_repositories with per-repo webhook secret
+    // Unique constraint is on (company_id, repo_url)
+    await executeQuery(`
+        INSERT INTO rapport.git_repositories (
+            repo_id, repo_name, repo_url, company_id, webhook_secret, created_at, updated_at
+        ) VALUES (gen_random_uuid(), $1, $2, $3, $4, NOW(), NOW())
+        ON CONFLICT (company_id, repo_url) DO UPDATE SET
+            webhook_secret = EXCLUDED.webhook_secret,
+            updated_at = NOW()
+    `, [`${owner}/${repo}`, repoUrl, companyId, webhookSecret]);
+
+    console.log(`Created GitHub webhook ${githubWebhookId} on ${owner}/${repo}`);
+    return true;
+}
+
+function decryptToken(encryptedData, key) {
+    const [ivHex, encrypted] = encryptedData.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+
 exports.handler = wrapHandler(createProject);

package/src/handlers/projects/projectDelete.js

@@ -29,14 +29,14 @@ async function deleteProject({ queryStringParameters: queryParams = {}, requestC
                 p.project_id,
                 p.company_id,
                 pc.role,
-                ue."Admin" as company_admin
+                ue.admin as company_admin
             FROM rapport.projects p
             LEFT JOIN rapport.project_collaborators pc
                 ON p.project_id = pc.project_id
                 AND pc.email_address = $1
-            LEFT JOIN "UserEntitlements" ue
-                ON ue."Email_Address" = $1
-                AND ue."Company_ID" = p.company_id
+            LEFT JOIN rapport.user_entitlements ue
+                ON ue.email_address = $1
+                AND ue.company_id = p.company_id
             WHERE p.project_id = $2
         `;
         const accessCheck = await executeQuery(accessQuery, [email, projectId]);

package/src/handlers/projects/projectGet.js

@@ -20,10 +20,10 @@ async function getProjects({ queryStringParameters: queryParams = {}, requestCon
 
         // Get user's company access
         const entitlementQuery = `
-            SELECT ue."Company_ID", ue."Admin", c."Company_Name"
-            FROM "UserEntitlements" ue
-            JOIN "Company" c ON ue."Company_ID" = c."Company_ID"
-            WHERE ue."Email_Address" = $1
+            SELECT ue.company_id, ue.admin, c.company_name
+            FROM rapport.user_entitlements ue
+            JOIN rapport.companies c ON ue.company_id = c.company_id
+            WHERE ue.email_address = $1
         `;
         const entitlements = await executeQuery(entitlementQuery, [email]);
 
@@ -31,7 +31,7 @@ async function getProjects({ queryStringParameters: queryParams = {}, requestCon
             return createErrorResponse(403, 'No company access');
         }
 
-        const companyIds = entitlements.rows.map(e => e.Company_ID);
+        const companyIds = entitlements.rows.map(e => e.company_id);
 
         // Optional filter by specific company
         let targetCompanyIds = companyIds;
@@ -53,7 +53,7 @@ async function getProjects({ queryStringParameters: queryParams = {}, requestCon
                 p.created_at,
                 p.last_active,
                 p.archived,
-                c."Company_Name",
+                c.company_name,
                 COUNT(DISTINCT pc.email_address) as collaborator_count,
                 COALESCE(
                     json_agg(
@@ -66,11 +66,11 @@ async function getProjects({ queryStringParameters: queryParams = {}, requestCon
                     '[]'
                 ) as collaborators
             FROM rapport.projects p
-            JOIN "Company" c ON p.company_id = c."Company_ID"
+            JOIN rapport.companies c ON p.company_id = c.company_id
             LEFT JOIN rapport.project_collaborators pc ON p.project_id = pc.project_id
             WHERE p.company_id = ANY($1::varchar[])
             AND p.archived = false
-            GROUP BY p.project_id, c."Company_Name"
+            GROUP BY p.project_id, c.company_name
             ORDER BY p.last_active DESC NULLS LAST, p.created_at DESC
         `;
 

package/src/handlers/projects/projectUpdate.js

@@ -30,14 +30,14 @@ async function updateProject({ body: requestBody = {}, requestContext }) {
                 p.project_id,
                 p.company_id,
                 pc.role,
-                ue."Admin" as company_admin
+                ue.admin as company_admin
             FROM rapport.projects p
             LEFT JOIN rapport.project_collaborators pc
                 ON p.project_id = pc.project_id
                 AND pc.email_address = $1
-            LEFT JOIN "UserEntitlements" ue
-                ON ue."Email_Address" = $1
-                AND ue."Company_ID" = p.company_id
+            LEFT JOIN rapport.user_entitlements ue
+                ON ue.email_address = $1
+                AND ue.company_id = p.company_id
             WHERE p.project_id = $2
         `;
         const accessCheck = await executeQuery(accessQuery, [email, projectId]);

package/src/handlers/reports/aiLeverage.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);
@@ -49,7 +49,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
                 AVG(s.duration_seconds / 60.0) as avg_session_minutes
             FROM rapport.sessions s
             JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p."Company_ID" = $1
+            WHERE p.company_id = $1
             AND s.started_at >= $2
         `, [userCompanyId, periodStart]);
     } catch (e) {
@@ -69,7 +69,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_email, dm.developer_name
             ORDER BY total_commits DESC
@@ -86,7 +86,7 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
             SELECT DISTINCT s.email_address
             FROM rapport.sessions s
             JOIN rapport.projects p ON s.project_id = p.project_id
-            WHERE p."Company_ID" = $1
+            WHERE p.company_id = $1
             AND s.started_at >= $2
         `, [userCompanyId, periodStart]);
     } catch (e) {
@@ -106,6 +106,9 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
     };
 
     const sessionData = sessionMetrics.rows[0] || {};
+    const multiplier = calculateMultiplier(aiAssistedDevs, nonAiDevs);
+    const totalCommits = devMetrics.rows.reduce((sum, d) => sum + parseInt(d.total_commits || 0), 0);
+    const aiCommits = aiAssistedDevs.reduce((sum, d) => sum + parseInt(d.total_commits || 0), 0);
 
     return createSuccessResponse({
         report_type: 'ai_leverage',
@@ -113,28 +116,29 @@ exports.handler = wrapHandler(async ({ requestContext, queryStringParameters })
         period_start: periodStart.toISOString(),
         period_end: new Date().toISOString(),
         summary: {
-            ai_sessions: parseInt(sessionData.total_sessions) || 0,
-            ai_users: aiAssistedDevs.length,
-            non_ai_users: nonAiDevs.length,
-            avg_session_minutes: parseFloat(sessionData.avg_session_minutes || 0).toFixed(1)
+            total_sessions: parseInt(sessionData.total_sessions) || 0,
+            unique_ai_users: aiAssistedDevs.length,
+            avg_session_minutes: parseFloat(sessionData.avg_session_minutes || 0).toFixed(1),
+            ai_assisted_commits: aiCommits,
+            total_commits: totalCommits,
+            ai_commit_percentage: totalCommits > 0 ? ((aiCommits / totalCommits) * 100).toFixed(1) : '0',
+            productivity_multiplier: multiplier.available ? multiplier.value : '1.0'
         },
-        ai_assisted: {
-            developers_count: aiAssistedDevs.length,
-            avg_commits: calcAvg(aiAssistedDevs, 'total_commits').toFixed(1),
-            avg_lines: calcAvg(aiAssistedDevs, 'lines_added').toFixed(0),
-            avg_prs: calcAvg(aiAssistedDevs, 'prs_merged').toFixed(1),
-            avg_compliance: calcAvg(aiAssistedDevs, 'avg_compliance').toFixed(1),
-            developers: aiAssistedDevs
+        comparison: {
+            ai_assisted: {
+                developer_count: aiAssistedDevs.length,
+                avg_commits_per_dev: calcAvg(aiAssistedDevs, 'total_commits').toFixed(1),
+                avg_lines_per_dev: calcAvg(aiAssistedDevs, 'lines_added').toFixed(0),
+                avg_compliance: calcAvg(aiAssistedDevs, 'avg_compliance').toFixed(1)
+            },
+            non_ai: {
+                developer_count: nonAiDevs.length,
+                avg_commits_per_dev: calcAvg(nonAiDevs, 'total_commits').toFixed(1),
+                avg_lines_per_dev: calcAvg(nonAiDevs, 'lines_added').toFixed(0),
+                avg_compliance: calcAvg(nonAiDevs, 'avg_compliance').toFixed(1)
+            }
         },
-        non_ai: {
-            developers_count: nonAiDevs.length,
-            avg_commits: calcAvg(nonAiDevs, 'total_commits').toFixed(1),
-            avg_lines: calcAvg(nonAiDevs, 'lines_added').toFixed(0),
-            avg_prs: calcAvg(nonAiDevs, 'prs_merged').toFixed(1),
-            avg_compliance: calcAvg(nonAiDevs, 'avg_compliance').toFixed(1),
-            developers: nonAiDevs
-        },
-        productivity_multiplier: calculateMultiplier(aiAssistedDevs, nonAiDevs),
+        standards_effectiveness: [],
         insights: generateInsights(aiAssistedDevs, nonAiDevs, sessionData)
     });
 });