@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/hooks/session-start.js

@@ -23,7 +23,7 @@ function generateFingerprint(userId, companyId, tier) {
     user_id: userId || 'anonymous',
     company_id: companyId || 'unknown',
     timestamp: new Date().toISOString(),
-    subscription_tier: tier || 'free'
+    subscription_tier: tier || 'enterprise'
   };
 
   const base64Fingerprint = Buffer.from(JSON.stringify(fingerprint)).toString('base64');
@@ -81,6 +81,274 @@ function filterStandardsByPreferences(standards, preferences) {
   });
 }
 
+/**
+ * Detect git remote URL from current directory
+ * @returns {Promise<string|null>} Git remote URL or null
+ */
+async function detectGitRemote() {
+  const { execSync } = require('child_process');
+  try {
+    const remote = execSync('git remote get-url origin', {
+      cwd: process.cwd(),
+      encoding: 'utf-8',
+      timeout: 2000,
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+    return remote || null;
+  } catch (error) {
+    // Not a git repo or no remote
+    return null;
+  }
+}
+
+/**
+ * Get project name from git remote URL or directory name
+ * @param {string|null} gitRemote - Git remote URL
+ * @returns {string} Project name
+ */
+function getProjectNameFromRemote(gitRemote) {
+  if (gitRemote) {
+    // Extract repo name from URL (handles both HTTPS and SSH)
+    // https://github.com/user/repo.git -> repo
+    // git@github.com:user/repo.git -> repo
+    const match = gitRemote.match(/\/([^\/]+?)(\.git)?$/);
+    if (match) {
+      return match[1];
+    }
+  }
+  // Fallback to directory name
+  return path.basename(process.cwd());
+}
+
+/**
+ * Auto-create project if it doesn't exist
+ * Called when .mindmeld/config.json is missing but user is authenticated
+ * @param {string} authToken - Auth token for API calls
+ * @param {string} apiUrl - API base URL
+ * @returns {Promise<Object|null>} Created/existing project config or null
+ */
+async function autoCreateProject(authToken, apiUrl) {
+  if (!authToken) {
+    return null;
+  }
+
+  const https = require('https');
+  const url = require('url');
+
+  // 1. Detect git remote
+  const gitRemote = await detectGitRemote();
+  const projectName = getProjectNameFromRemote(gitRemote);
+
+  // 2. Get user's entitlements to find company
+  let companyId = null;
+  let clientId = null;
+  let userEmail = null;
+  let subscriptionTier = 'enterprise';
+
+  try {
+    const entitlementsResponse = await makeHttpRequest(
+      `${apiUrl}/api/users/entitlements`,
+      'GET',
+      null,
+      authToken,
+      3000
+    );
+
+    if (entitlementsResponse && entitlementsResponse.Records && entitlementsResponse.Records.length > 0) {
+      // Use first client's first company (user's primary organization)
+      const primaryClient = entitlementsResponse.Records[0];
+      clientId = primaryClient.client_id;
+      subscriptionTier = primaryClient.subscription_tier || 'enterprise';
+
+      if (primaryClient.companies && primaryClient.companies.length > 0) {
+        // Prefer a company where user is admin
+        const adminCompany = primaryClient.companies.find(c => c.admin);
+        const targetCompany = adminCompany || primaryClient.companies[0];
+        companyId = targetCompany.company_id;
+      }
+    }
+
+    // Also get user email from /api/users/me
+    const userResponse = await makeHttpRequest(
+      `${apiUrl}/api/users/me`,
+      'GET',
+      null,
+      authToken,
+      2000
+    );
+    if (userResponse && userResponse.data) {
+      userEmail = userResponse.data.email_address || userResponse.data.Email_Address;
+    }
+  } catch (e) {
+    console.error('[MindMeld] Could not fetch user info:', e.message);
+  }
+
+  if (!companyId) {
+    // User not set up with a company yet
+    console.error('[MindMeld] User has no company. Complete onboarding at app.mindmeld.dev');
+    return null;
+  }
+
+  // 3. Check if project already exists
+  try {
+    const projectsResponse = await makeHttpRequest(
+      `${apiUrl}/api/projects?Company_ID=${encodeURIComponent(companyId)}`,
+      'GET',
+      null,
+      authToken,
+      3000
+    );
+
+    if (projectsResponse && projectsResponse.Records) {
+      // Look for existing project by name or repo URL
+      const existing = projectsResponse.Records.find(p =>
+        p.project_name === projectName ||
+        (gitRemote && p.repo_url === gitRemote)
+      );
+
+      if (existing) {
+        // Project exists - save config locally and return
+        const config = {
+          projectId: existing.project_id,
+          projectName: existing.project_name,
+          companyId: existing.company_id,
+          userEmail: userEmail,
+          subscriptionTier: subscriptionTier,
+          repoUrl: existing.repo_url || gitRemote,
+          autoCreated: false
+        };
+        await saveLocalConfig(config);
+        console.error(`[MindMeld] Linked to existing project: ${existing.project_name}`);
+        return config;
+      }
+    }
+  } catch (e) {
+    console.error('[MindMeld] Could not check existing projects:', e.message);
+  }
+
+  // 4. Create new project
+  try {
+    const createPayload = {
+      Company_ID: companyId,
+      project_name: projectName,
+      description: `Auto-created from ${gitRemote || process.cwd()}`,
+      private: true,
+      repo_url: gitRemote
+    };
+
+    const createResponse = await makeHttpRequest(
+      `${apiUrl}/api/projects`,
+      'POST',
+      createPayload,
+      authToken,
+      5000
+    );
+
+    if (createResponse && createResponse.Records && createResponse.Records.length > 0) {
+      const created = createResponse.Records[0];
+      const config = {
+        projectId: created.project_id,
+        projectName: created.project_name,
+        companyId: created.company_id,
+        userEmail: userEmail,
+        subscriptionTier: subscriptionTier,
+        repoUrl: gitRemote,
+        autoCreated: true,
+        createdAt: new Date().toISOString()
+      };
+      await saveLocalConfig(config);
+      console.error(`[MindMeld] Auto-created project: ${created.project_name}`);
+      return config;
+    } else if (createResponse && createResponse.error) {
+      console.error('[MindMeld] Project creation failed:', createResponse.error);
+    }
+  } catch (e) {
+    console.error('[MindMeld] Could not create project:', e.message);
+  }
+
+  return null;
+}
+
+/**
+ * Save project config locally to .mindmeld/config.json
+ * @param {Object} config - Project configuration
+ */
+async function saveLocalConfig(config) {
+  const configDir = path.join(process.cwd(), '.mindmeld');
+  const configPath = path.join(configDir, 'config.json');
+
+  try {
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error('[MindMeld] Could not save config:', error.message);
+  }
+}
+
+/**
+ * Make HTTP request helper
+ * @param {string} urlStr - Full URL
+ * @param {string} method - HTTP method
+ * @param {Object|null} body - Request body
+ * @param {string|null} authToken - Bearer token
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Object>} Response object
+ */
+function makeHttpRequest(urlStr, method, body, authToken, timeout = 5000) {
+  const https = require('https');
+  const url = require('url');
+
+  return new Promise((resolve) => {
+    const parsedUrl = url.parse(urlStr);
+    const payload = body ? JSON.stringify(body) : null;
+
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || 443,
+      path: parsedUrl.path,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      },
+      timeout: timeout
+    };
+
+    if (authToken) {
+      options.headers['Authorization'] = `Bearer ${authToken}`;
+    }
+    if (payload) {
+      options.headers['Content-Length'] = Buffer.byteLength(payload);
+    }
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (res.statusCode >= 400) {
+            resolve({ error: parsed.message || `HTTP ${res.statusCode}`, status: res.statusCode });
+          } else {
+            resolve(parsed);
+          }
+        } catch (e) {
+          resolve({ error: 'Invalid JSON response' });
+        }
+      });
+    });
+
+    req.on('error', (err) => resolve({ error: err.message }));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ error: 'Request timeout' });
+    });
+
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
 /**
  * Load user and company info from MindMeld config
  * @returns {Promise<{userId: string, companyId: string, tier: string}>}
@@ -91,10 +359,11 @@ async function loadFingerprintConfig() {
     const configContent = await fs.readFile(configPath, 'utf-8');
     const config = JSON.parse(configContent);
 
+    // Support both snake_case and camelCase keys for backwards compatibility
     return {
-      userId: config.user_id || process.env.MINDMELD_USER_ID || 'anonymous',
-      companyId: config.company_id || process.env.MINDMELD_COMPANY_ID || 'unknown',
-      tier: config.subscription_tier || process.env.MINDMELD_TIER || 'free'
+      userId: config.user_id || config.userId || config.userEmail || process.env.MINDMELD_USER_ID || 'anonymous',
+      companyId: config.company_id || config.companyId || process.env.MINDMELD_COMPANY_ID || 'unknown',
+      tier: config.subscription_tier || config.subscriptionTier || process.env.MINDMELD_TIER || 'enterprise'
     };
   } catch (error) {
     // Expected: config doesn't exist or invalid JSON
@@ -105,7 +374,7 @@ async function loadFingerprintConfig() {
     return {
       userId: process.env.MINDMELD_USER_ID || 'anonymous',
       companyId: process.env.MINDMELD_COMPANY_ID || 'unknown',
-      tier: process.env.MINDMELD_TIER || 'free'
+      tier: process.env.MINDMELD_TIER || 'enterprise'
     };
   }
 }
@@ -153,10 +422,27 @@ async function loadAuthToken() {
 }
 
 /**
- * Load Cognito config from .myworld.json (dev vs prod detection)
+ * Load Cognito config
+ * Priority: .mindmeld/config.json → .myworld.json → production defaults
  * @returns {Promise<Object>} Cognito constructor options or empty object (uses prod defaults)
  */
 async function loadCognitoConfig() {
+  // 1. Check .mindmeld/config.json first (always points to prod)
+  try {
+    const mindmeldConfigPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(mindmeldConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    if (config.auth?.cognitoDomain && config.auth?.cognitoClientId) {
+      return {
+        cognitoDomain: config.auth.cognitoDomain,
+        cognitoClientId: config.auth.cognitoClientId
+      };
+    }
+  } catch (error) {
+    // No .mindmeld/config.json or no auth section
+  }
+
+  // 2. Fallback to .myworld.json (may point to dev — for backwards compatibility)
   try {
     const configPath = path.join(process.cwd(), '.myworld.json');
     const content = await fs.readFile(configPath, 'utf-8');
@@ -198,20 +484,33 @@ function spawnBackgroundLogin() {
 }
 
 /**
- * Load API and Cognito configuration from .myworld.json
- * @returns {Promise<{apiUrl: string, cognitoDomain?: string, cognitoClientId?: string}>}
+ * Load API configuration
+ * Priority: .mindmeld/config.json → .myworld.json → env var → production default
+ * The hook should always talk to the production MindMeld API for standards/patterns,
+ * regardless of which environment the developer is building against.
+ * @returns {Promise<{apiUrl: string}>}
  */
 async function loadApiConfig() {
+  // 1. Check .mindmeld/config.json first (always points to prod)
+  try {
+    const mindmeldConfigPath = path.join(process.cwd(), '.mindmeld', 'config.json');
+    const content = await fs.readFile(mindmeldConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    if (config.apiUrl) {
+      return { apiUrl: config.apiUrl };
+    }
+  } catch (error) {
+    // No .mindmeld/config.json or no apiUrl
+  }
+
+  // 2. Fallback to .myworld.json (may point to dev)
   try {
     const configPath = path.join(process.cwd(), '.myworld.json');
     const content = await fs.readFile(configPath, 'utf-8');
     const config = JSON.parse(content);
     const backend = config.deployments?.backend;
-    const auth = backend?.auth;
     return {
-      apiUrl: backend?.api?.base_url || 'https://api.mindmeld.dev',
-      cognitoDomain: auth?.domain ? `${auth.domain}.auth.us-east-2.amazoncognito.com` : undefined,
-      cognitoClientId: auth?.client_id || undefined
+      apiUrl: backend?.api?.base_url || 'https://api.mindmeld.dev'
     };
   } catch (error) {
     return {
@@ -268,7 +567,7 @@ async function fetchRelevantStandardsFromAPI(apiUrl, authToken, characteristics,
           if (res.statusCode >= 400) {
             reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
           } else {
-            resolve(parsed.standards || []);
+            resolve(parsed.data?.standards || parsed.standards || []);
           }
         } catch (e) {
           reject(new Error('Invalid API response'));
@@ -287,6 +586,79 @@ async function fetchRelevantStandardsFromAPI(apiUrl, authToken, characteristics,
   });
 }
 
+/**
+ * Fetch weekly splash data from API
+ * Returns splash summary with stats, or null if already acknowledged
+ */
+async function fetchSplashData(apiUrl, authToken) {
+  if (!authToken) return null;
+
+  const https = require('https');
+  const url = require('url');
+  const parsedUrl = url.parse(`${apiUrl}/api/user/splash`);
+
+  const options = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || 443,
+    path: parsedUrl.path,
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${authToken}`
+    },
+    timeout: 3000
+  };
+
+  return new Promise((resolve) => {
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve(parsed.data || parsed);
+        } catch (e) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}
+
+/**
+ * Acknowledge splash (fire-and-forget) to prevent showing again this week
+ */
+function acknowledgeSplash(apiUrl, authToken, weekStart) {
+  if (!authToken || !weekStart) return;
+
+  const https = require('https');
+  const url = require('url');
+  const payload = JSON.stringify({ week_start: weekStart });
+  const parsedUrl = url.parse(`${apiUrl}/api/user/splash/acknowledge`);
+
+  const options = {
+    hostname: parsedUrl.hostname,
+    port: parsedUrl.port || 443,
+    path: parsedUrl.path,
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${authToken}`,
+      'Content-Length': Buffer.byteLength(payload)
+    },
+    timeout: 3000
+  };
+
+  const req = https.request(options, () => {}); // fire-and-forget
+  req.on('error', () => {}); // silently ignore
+  req.on('timeout', () => req.destroy());
+  req.write(payload);
+  req.end();
+}
+
 /**
  * Main hook execution
  */
@@ -294,19 +666,39 @@ async function injectContext() {
   const startTime = Date.now();
 
   try {
-    // Fast bail if MindMeld not configured
-    const hasMindmeld = await checkMindmeldConfiguration();
+    // Check if MindMeld is configured for this project
+    let hasMindmeld = await checkMindmeldConfiguration();
+
+    // If not configured, try auto-create for authenticated users
     if (!hasMindmeld) {
-      // Check if user is a subscriber but this project isn't initialized
-      try {
-        const os = require('os');
-        const authPath = path.join(os.homedir(), '.mindmeld', 'auth.json');
-        await fs.access(authPath);
-        console.error('[MindMeld] Project not initialized. Run "mindmeld init" in this directory.');
-      } catch (e) {
-        // No auth file — not a subscriber, stay silent
+      // Load auth token and API config first
+      const [authToken, apiConfig] = await Promise.all([
+        loadAuthToken(),
+        loadApiConfig()
+      ]);
+
+      if (authToken) {
+        // User is authenticated - try to auto-create project
+        console.error('[MindMeld] No project config found. Auto-detecting...');
+        const autoCreated = await autoCreateProject(authToken, apiConfig.apiUrl);
+        if (autoCreated) {
+          hasMindmeld = true; // Config now exists
+        }
+      } else {
+        // Not authenticated - check if they have auth file but token expired
+        try {
+          const os = require('os');
+          const authPath = path.join(os.homedir(), '.mindmeld', 'auth.json');
+          await fs.access(authPath);
+          console.error('[MindMeld] Auth token expired. Run "mindmeld login" to refresh.');
+        } catch (e) {
+          // No auth file — not a subscriber, stay silent
+        }
+      }
+
+      if (!hasMindmeld) {
+        return '';
       }
-      return '';
     }
 
     // 1. Parallel local reads (no network, no DB)
@@ -334,27 +726,54 @@ async function injectContext() {
 
     const sessionId = mindmeld.generateSessionId();
 
+    // 3b. Persist session context for pre-compact hook
+    // Pre-compact creates a new MindmeldClient and needs project context
+    try {
+      const sessionContext = {
+        sessionId: sessionId,
+        projectId: context.projectId,
+        projectName: context.projectName,
+        companyId: context.companyId,
+        userEmail: context.userEmail,
+        startedAt: new Date().toISOString()
+      };
+      const mindmeldDir = path.join(process.cwd(), '.mindmeld');
+      await fs.mkdir(mindmeldDir, { recursive: true });
+      await fs.writeFile(
+        path.join(mindmeldDir, 'current-session.json'),
+        JSON.stringify(sessionContext, null, 2)
+      );
+    } catch (err) {
+      console.error('[MindMeld] Could not persist session context (non-fatal):', err.message);
+    }
+
     // 4. Detect project characteristics locally (file system only, no DB)
     const characteristics = await mindmeld.relevanceDetector.detectProjectCharacteristics();
 
-    // 5. Parallel API calls: standards + team context
-    const [standardsResult, projectContextResult] = await Promise.allSettled([
+    // 5. Parallel API calls: standards + team context + splash
+    const [standardsResult, projectContextResult, splashResult] = await Promise.allSettled([
       fetchRelevantStandardsFromAPI(apiConfig.apiUrl, authToken, characteristics, context.projectId, preferences),
-      mindmeld.loadProjectContext(context.projectId)
+      mindmeld.loadProjectContext(context.projectId),
+      fetchSplashData(apiConfig.apiUrl, authToken)
     ]);
 
-    // 6. Resolve standards: API → file-based fallback
+    // 6. Resolve standards: API → file-based fallback (only for network errors, not subscription blocks)
     let relevantStandards = [];
     if (standardsResult.status === 'fulfilled' && standardsResult.value.length > 0) {
       relevantStandards = standardsResult.value;
       console.error(`[MindMeld] ${relevantStandards.length} standards from API`);
+    } else if (standardsResult.status === 'rejected' &&
+               standardsResult.reason.message.includes('subscription required')) {
+      // Subscription enforcement — do NOT fall through to file-based injection
+      console.error('[MindMeld] Active subscription required. Subscribe at app.mindmeld.dev');
+      return '';
     } else {
       if (standardsResult.status === 'rejected') {
         console.error(`[MindMeld] API fallback: ${standardsResult.reason.message}`);
       }
       const categories = mindmeld.relevanceDetector.mapCharacteristicsToCategories(characteristics);
-      relevantStandards = await mindmeld.relevanceDetector.loadStandardsFromFiles(categories);
-      console.error(`[MindMeld] ${relevantStandards.length} standards from file fallback`);
+      relevantStandards = await mindmeld.relevanceDetector.loadStandardsFromFiles(categories, characteristics);
+      console.error(`[MindMeld] ${relevantStandards.length} standards from file fallback (scored)`);
     }
 
     // 7. Filter by project preferences
@@ -367,7 +786,7 @@ async function injectContext() {
     relevantStandards = relevantStandards.slice(0, 10);
 
     // 8. Record standards shown (fire-and-forget, non-blocking)
-    mindmeld.recordStandardsShown(sessionId, relevantStandards);
+    mindmeld.recordStandardsShown(sessionId, relevantStandards, context.projectId, context.userEmail);
 
     // 9. Resolve team context from parallel API call
     const projectContext = projectContextResult.status === 'fulfilled' ? projectContextResult.value : null;
@@ -378,7 +797,15 @@ async function injectContext() {
       ? projectContext.recentLearning
       : [];
 
-    // 10. Build context injection with fingerprint
+    // 10. Resolve splash data
+    const splashData = splashResult.status === 'fulfilled' ? splashResult.value : null;
+
+    // Auto-acknowledge splash (fire-and-forget) so it doesn't show again this week
+    if (splashData && splashData.show_splash && splashData.summary) {
+      acknowledgeSplash(apiConfig.apiUrl, authToken, splashData.summary.week_start);
+    }
+
+    // 11. Build context injection with fingerprint
     const injection = formatContextInjection({
       project: context.projectName,
       sessionId: sessionId,
@@ -386,9 +813,17 @@ async function injectContext() {
       relevantStandards: relevantStandards,
       teamPatterns: teamPatterns,
       recentLearning: recentLearning,
-      fingerprint: fingerprintConfig
+      fingerprint: fingerprintConfig,
+      splash: splashData
     });
 
+    // 12. Cache condensed context for subagent injection
+    try {
+      await cacheSubagentContext(relevantStandards, teamPatterns, context.projectName);
+    } catch (cacheError) {
+      console.error('[MindMeld] Subagent context cache failed (non-fatal):', cacheError.message);
+    }
+
     const elapsed = Date.now() - startTime;
     console.error(`[MindMeld] Context injected in ${elapsed}ms`);
 
@@ -418,6 +853,46 @@ async function checkMindmeldConfiguration() {
   }
 }
 
+/**
+ * Cache condensed context for subagent injection
+ * Subagents don't get session-start hooks, so we cache the essentials
+ * to a file that SubagentStart can read instantly (< 50ms)
+ *
+ * @param {Array} standards - Relevant standards from API
+ * @param {Array} teamPatterns - Team patterns
+ * @param {string} projectName - Current project name
+ */
+async function cacheSubagentContext(standards, teamPatterns, projectName) {
+  const mindmeldDir = path.join(process.cwd(), '.mindmeld');
+  const cachePath = path.join(mindmeldDir, 'subagent-context.md');
+
+  const sections = [];
+  sections.push(`# MindMeld Standards Context (${projectName})`);
+  sections.push('');
+  sections.push('Follow these standards when writing or modifying code:');
+  sections.push('');
+
+  // Include standards as compact rules (no examples/anti-patterns to save tokens)
+  if (standards && standards.length > 0) {
+    for (const s of standards) {
+      sections.push(`- **${s.element}** [${s.category}]: ${s.rule}`);
+    }
+    sections.push('');
+  }
+
+  // Include team patterns as compact rules
+  if (teamPatterns && teamPatterns.length > 0) {
+    sections.push('## Team Patterns');
+    for (const p of teamPatterns) {
+      sections.push(`- **${p.element}** (${(p.correlation * 100).toFixed(0)}% correlation): ${p.rule}`);
+    }
+    sections.push('');
+  }
+
+  await fs.writeFile(cachePath, sections.join('\n'));
+  console.error(`[MindMeld] Cached subagent context (${sections.length} lines)`);
+}
+
 /**
  * Format context injection for Claude Code
  * @param {object} data - Context data to inject
@@ -431,7 +906,8 @@ function formatContextInjection(data) {
     relevantStandards,
     teamPatterns,
     recentLearning,
-    fingerprint
+    fingerprint,
+    splash
   } = data;
 
   const sections = [];
@@ -453,6 +929,34 @@ function formatContextInjection(data) {
   sections.push('Licensed for use within MindMeld platform only. Redistribution prohibited.');
   sections.push('');
 
+  // Weekly splash (shown once per week)
+  if (splash && splash.show_splash) {
+    if (splash.is_greenfield && splash.tips && splash.tips.length > 0) {
+      sections.push('## Getting Started with MindMeld');
+      for (const tip of splash.tips) {
+        sections.push(`- ${tip}`);
+      }
+      sections.push('');
+    } else if (splash.summary) {
+      const s = splash.summary;
+      const formatDate = (dateStr) => {
+        const d = new Date(dateStr + 'T00:00:00Z');
+        return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric', timeZone: 'UTC' });
+      };
+      const hours = Math.floor(s.total_duration_minutes / 60);
+      const mins = s.total_duration_minutes % 60;
+      const duration = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+
+      sections.push(`## Weekly Recap (${formatDate(s.week_start)} - ${formatDate(s.week_end)})`);
+      sections.push(`${s.sessions_count} sessions | ${duration} total | ${s.active_projects} project${s.active_projects !== 1 ? 's' : ''}`);
+      sections.push(`${s.standards_injected} standards injected, ${s.standards_followed} followed, ${s.violations_detected} violation${s.violations_detected !== 1 ? 's' : ''}`);
+      if (s.patterns_harvested > 0) {
+        sections.push(`${s.patterns_harvested} patterns harvested`);
+      }
+      sections.push('');
+    }
+  }
+
   // Collaborators
   if (collaborators && collaborators.length > 0) {
     sections.push('## Team');
@@ -460,30 +964,120 @@ function formatContextInjection(data) {
     sections.push('');
   }
 
-  // Relevant standards (top 10 only)
+  // Separate standards and workflows
+  const standards = [];
+  const workflows = [];
+
   if (relevantStandards && relevantStandards.length > 0) {
+    for (const item of relevantStandards) {
+      // Detect workflows: check type flag, rule prefix, keywords, or structured examples
+      const isWorkflow = item.type === 'workflow' ||
+        (item.rule && item.rule.startsWith('WORKFLOW:')) ||
+        (Array.isArray(item.keywords) && item.keywords.includes('workflow') && item.examples && item.examples[0]?.type === 'workflow') ||
+        (item.tags && item.tags.includes('workflow') && item.examples && item.examples[0]?.type === 'workflow');
+
+      if (isWorkflow) {
+        workflows.push(item);
+      } else {
+        standards.push(item);
+      }
+    }
+  }
+
+  // Relevant standards
+  if (standards.length > 0) {
     sections.push('## Relevant Standards');
     sections.push('');
 
-    for (const standard of relevantStandards) {
+    for (const standard of standards) {
       sections.push(`### ${standard.element}`);
       sections.push(`**Category**: ${standard.category}`);
       // Add fingerprint to rule text
       sections.push(`**Rule**: ${standard.rule} ${fingerprintStr}`);
 
       if (standard.examples && standard.examples.length > 0) {
-        sections.push('');
-        sections.push('**Example**:');
-        sections.push('```javascript');
-        sections.push(standard.examples[0].code);
-        sections.push('```');
+        const example = standard.examples[0];
+        const exampleCode = typeof example === 'string' ? example : (example?.code || example?.description || '');
+        if (exampleCode) {
+          sections.push('');
+          sections.push('**Example**:');
+          sections.push('```javascript');
+          sections.push(exampleCode);
+          sections.push('```');
+        }
       }
 
       if (standard.anti_patterns && standard.anti_patterns.length > 0) {
         sections.push('');
         sections.push('**Anti-patterns**:');
         for (const antiPattern of standard.anti_patterns) {
-          sections.push(`- ❌ ${antiPattern.description}`);
+          const desc = typeof antiPattern === 'string' ? antiPattern : (antiPattern?.description || '');
+          if (desc) {
+            sections.push(`- ❌ ${desc}`);
+          }
+        }
+      }
+
+      sections.push('');
+    }
+  }
+
+  // Workflows (rendered as ordered procedures)
+  if (workflows.length > 0) {
+    sections.push('## Workflows');
+    sections.push('');
+
+    for (const workflow of workflows) {
+      // Extract workflow data from examples[0]
+      const workflowData = workflow.examples && workflow.examples[0]?.type === 'workflow'
+        ? workflow.examples[0]
+        : null;
+
+      sections.push(`### ${workflow.element} ${fingerprintStr}`);
+      sections.push(`**Category**: ${workflow.category}`);
+
+      if (workflowData) {
+        sections.push(`**When**: ${workflowData.trigger}`);
+        sections.push('');
+
+        // Preconditions
+        if (workflowData.preconditions && workflowData.preconditions.length > 0) {
+          sections.push('**Preconditions**:');
+          for (const pre of workflowData.preconditions) {
+            sections.push(`- ${pre}`);
+          }
+          sections.push('');
+        }
+
+        // Steps
+        if (workflowData.steps && workflowData.steps.length > 0) {
+          sections.push('**Steps**:');
+          for (const step of workflowData.steps) {
+            const gateMarker = step.gate ? ' (GATE)' : '';
+            sections.push(`${step.index}. **${step.name}**${gateMarker} — ${step.description}`);
+
+            if (step.command) {
+              // Clean up multiline commands for display
+              const cmd = step.command.trim().split('\n')[0];
+              sections.push(`   \`${cmd}\``);
+            }
+
+            if (step.validation) {
+              sections.push(`   Verify: ${step.validation}`);
+            }
+          }
+          sections.push('');
+        }
+      }
+
+      // Anti-patterns
+      if (workflow.anti_patterns && workflow.anti_patterns.length > 0) {
+        sections.push('**Anti-patterns**:');
+        for (const antiPattern of workflow.anti_patterns) {
+          const desc = typeof antiPattern === 'string' ? antiPattern : (antiPattern?.description || '');
+          if (desc) {
+            sections.push(`- ❌ ${desc}`);
+          }
         }
       }