bulltrackers-module 1.0.263 → 1.0.265

package/functions/computation-system/persistence/ResultCommitter.js

@@ -1,21 +1,17 @@
 /**
  * @fileoverview Handles saving computation results with observability and Smart Cleanup.
- * UPDATED: Returns detailed failure reports AND metrics for the Audit Logger.
- * UPDATED: Stops retrying on non-transient errors.
+ * UPDATED: Stores Hash Composition in status for audit trail.
  */
 const { commitBatchInChunks }              = require('./FirestoreUtils');
 const { updateComputationStatus }          = require('./StatusRepository');
 const { batchStoreSchemas }                = require('../utils/schema_capture');
 const { generateProcessId, PROCESS_TYPES } = require('../logger/logger');
-
 const { HeuristicValidator }               = require('./ResultsValidator');
 const validationOverrides                  = require('../config/validation_overrides'); 
+const pLimit                               = require('p-limit'); 
 
 const NON_RETRYABLE_ERRORS = [
-    'INVALID_ARGUMENT',      // Schema/Type mismatch
-    'PERMISSION_DENIED',     // Auth issue
-    'DATA_LOSS',             // Firestore corruption
-    'FAILED_PRECONDITION'    // Transaction requirements not met
+    'INVALID_ARGUMENT',      'PERMISSION_DENIED',     'DATA_LOSS',             'FAILED_PRECONDITION'
 ];
 
 async function commitResults(stateObj, dStr, passName, config, deps, skipStatusWrite = false) {
@@ -26,12 +22,11 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     const { logger, db } = deps;
     const pid            = generateProcessId(PROCESS_TYPES.STORAGE, passName, dStr);
     
-    const passNum = passName.replace(/[^0-9]/g, '');
+    const fanOutLimit = pLimit(10); 
 
     for (const name in stateObj) {
         const calc = stateObj[name];
         
-        // Prep metrics container
         const runMetrics = {
             storage: { sizeBytes: 0, isSharded: false, shardCount: 1, keys: 0 },
             validation: { isValid: true, anomalies: [] }
@@ -39,152 +34,92 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
 
         try {
             const result = await calc.getResult();
-
             const overrides   = validationOverrides[calc.manifest.name] || {};
             const healthCheck = HeuristicValidator.analyze(calc.manifest.name, result, overrides);
 
             if (!healthCheck.valid) {
-                // If validation failed, we consider it an anomaly but we BLOCK the write (throw error)
                 runMetrics.validation.isValid = false;
                 runMetrics.validation.anomalies.push(healthCheck.reason);
                 throw { message: healthCheck.reason, stage: 'QUALITY_CIRCUIT_BREAKER' };
             }
             
-            // Check for minor anomalies (validation warnings that didn't fail) - optional implementation
-            // For now, we assume if valid=true, anomalies are empty unless we add warning logic later.
-
             const isEmpty = !result || (typeof result === 'object' && Object.keys(result).length === 0) || (typeof result === 'number' && result === 0);
             if (isEmpty) { 
-                // Log empty success
                 if (calc.manifest.hash) { 
-                    successUpdates[name] = {  
-                        hash: false,  
-                        category: calc.manifest.category,
-                        metrics: runMetrics // Return empty metrics
+                    successUpdates[name] = { 
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category, 
+                        composition: calc.manifest.composition, // <--- Added Composition
+                        metrics: runMetrics 
                     }; 
                 } 
                 continue; 
             }
             
-            // Calculate Key Count rough estimate
             if (typeof result === 'object') runMetrics.storage.keys = Object.keys(result).length;
 
-            const mainDocRef = db.collection(config.resultsCollection)
-                .doc(dStr)
-                .collection(config.resultsSubcollection)
-                .doc(calc.manifest.category)
-                .collection(config.computationsSubcollection)
-                .doc(name);
-
-            // --- REACTIVE SELF-HEALING LOOP ---
-            let committed = false;
-            // Strategy: 1=Normal, 2=Safe (Halved), 3=Aggressive (Quartered + Key Limit)
-            const strategies = [
-                { bytes: 900 * 1024, keys: null },      // Attempt 1: Standard
-                { bytes: 450 * 1024, keys: 10000 },     // Attempt 2: High Index usage
-                { bytes: 200 * 1024, keys: 2000 }       // Attempt 3: Extreme fragmentation
-            ];
+            // ... (Fan-out logic remains same) ...
+            const resultKeys = Object.keys(result || {});
+            const isMultiDate = resultKeys.length > 0 && resultKeys.every(k => /^\d{4}-\d{2}-\d{2}$/.test(k));
 
-            let lastError = null;
-
-            for (let attempt = 0; attempt < strategies.length; attempt++) {
-                if (committed) break;
+            if (isMultiDate) {
+                logger.log('INFO', `[ResultCommitter] 🕰️ Multi-Date Output detected for ${name} (${resultKeys.length} days). Throttled Fan-Out...`);
                 
-                const constraints = strategies[attempt];
+                const datePromises = resultKeys.map((historicalDate) => fanOutLimit(async () => {
+                    const dailyData = result[historicalDate];
+                    if (!dailyData || Object.keys(dailyData).length === 0) return;
+
+                    const historicalDocRef = db.collection(config.resultsCollection)
+                        .doc(historicalDate)
+                        .collection(config.resultsSubcollection)
+                        .doc(calc.manifest.category)
+                        .collection(config.computationsSubcollection)
+                        .doc(name);
+
+                    await writeSingleResult(dailyData, historicalDocRef, name, historicalDate, logger, config, deps);
+                }));
                 
-                try {
-                    // 1. Prepare Shards with current constraints
-                    // This function now needs to help us determine sharding info
-                    const updates = await prepareAutoShardedWrites(result, mainDocRef, logger, constraints.bytes, constraints.keys);
-                    
-                    // METRICS CALCULATION
-                    const pointer = updates.find(u => u.data._completed === true);
-                    const isSharded = pointer && pointer.data._sharded === true;
-                    const shardCount = isSharded ? (pointer.data._shardCount || 1) : 1;
-                    const totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
-                    
-                    runMetrics.storage.sizeBytes = totalSize;
-                    runMetrics.storage.isSharded = isSharded;
-                    runMetrics.storage.shardCount = shardCount;
-
-                    // 2. Audit Ledger (Only add to the first update batch)
-                    if (passNum && calc.manifest) {
-                        const ledgerRef = db.collection(`computation_audit_ledger/${dStr}/passes/${passNum}/tasks`).doc(name);
-                        updates.push({
-                            ref: ledgerRef,
-                            data: {
-                                status: 'COMPLETED',
-                                completedAt: new Date(),
-                                actualHash: calc.manifest.hash,
-                                _verified: true,
-                                _shardingStrategy: attempt + 1
-                            },
-                            options: { merge: true }
-                        });
-                    }
-
-                    // 3. Attempt Commit
-                    await commitBatchInChunks(config, deps, updates, `${name} Results (Att ${attempt+1})`);
-                    
-                    // Log Success
-                    if (logger && logger.logStorage) { 
-                        logger.logStorage(pid, name, dStr, mainDocRef.path, totalSize, isSharded); 
-                    }
-                    
-                    committed = true; // Exit loop
+                await Promise.all(datePromises);
+                
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category, 
+                        composition: calc.manifest.composition, // <--- Added Composition
+                        metrics: runMetrics 
+                    }; 
+                }
 
-                } catch (commitErr) {
-                    lastError = commitErr;
-                    const msg = commitErr.message || '';
-                    
-                    const isNonRetryable = NON_RETRYABLE_ERRORS.includes(commitErr.code);
-                    if (isNonRetryable) {
-                        logger.log('ERROR', `[SelfHealing] ${name} encountered FATAL error (Attempt ${attempt + 1}): ${msg}. Aborting.`);
-                        throw commitErr; 
-                    }
+            } else {
+                // --- STANDARD MODE ---
+                const mainDocRef = db.collection(config.resultsCollection)
+                    .doc(dStr)
+                    .collection(config.resultsSubcollection)
+                    .doc(calc.manifest.category)
+                    .collection(config.computationsSubcollection)
+                    .doc(name);
 
-                    const isSizeError  = msg.includes('Transaction too big')    || msg.includes('payload is too large');
-                    const isIndexError = msg.includes('too many index entries') || msg.includes('INVALID_ARGUMENT'); 
+                const writeStats = await writeSingleResult(result, mainDocRef, name, dStr, logger, config, deps);
+                
+                runMetrics.storage.sizeBytes = writeStats.totalSize;
+                runMetrics.storage.isSharded = writeStats.isSharded;
+                runMetrics.storage.shardCount = writeStats.shardCount;
 
-                    if (isSizeError || isIndexError) {
-                        logger.log('WARN', `[SelfHealing] ${name} failed write attempt ${attempt + 1}. Retrying with tighter constraints...`, { error: msg });
-                        continue; // Try next strategy
-                    } else {
-                        logger.log('WARN', `[SelfHealing] ${name} unknown error (Attempt ${attempt + 1}). Retrying...`, { error: msg });
-                    }
+                if (calc.manifest.hash) { 
+                    successUpdates[name] = {  
+                        hash: calc.manifest.hash, 
+                        category: calc.manifest.category,
+                        composition: calc.manifest.composition, // <--- Added Composition
+                        metrics: runMetrics 
+                    }; 
                 }
             }
 
-            if (!committed) {
-                throw { 
-                    message: `Exhausted sharding strategies. Last error: ${lastError?.message}`, 
-                    stack: lastError?.stack, 
-                    stage: 'SHARDING_LIMIT_EXCEEDED' 
-                };
-            }
-            // ----------------------------------
-
-            // Mark Success & Pass Metrics
-            if (calc.manifest.hash) { 
-                successUpdates[name] = {  
-                    hash: calc.manifest.hash, 
-                    category: calc.manifest.category,
-                    metrics: runMetrics // Pass metrics up
-                }; 
-            }
-
-            // Capture Schema
             if (calc.manifest.class.getSchema) {
                 const { class: _cls, ...safeMetadata } = calc.manifest;
-                schemas.push({ 
-                    name, 
-                    category: calc.manifest.category, 
-                    schema: calc.manifest.class.getSchema(), 
-                    metadata: safeMetadata 
-                });
+                schemas.push({ name, category: calc.manifest.category, schema: calc.manifest.class.getSchema(), metadata: safeMetadata });
             }
 
-            // Cleanup Migration
             if (calc.manifest.previousCategory && calc.manifest.previousCategory !== calc.manifest.category) {
                 cleanupTasks.push(deleteOldCalculationData(dStr, calc.manifest.previousCategory, name, config, deps));
             }
@@ -198,7 +133,7 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
             failureReport.push({
                 name,
                 error: { message: msg, stack: e.stack, stage },
-                metrics: runMetrics // Pass incomplete metrics for debugging
+                metrics: runMetrics 
             });
         }
     }
@@ -210,107 +145,79 @@ async function commitResults(stateObj, dStr, passName, config, deps, skipStatusW
     return { successUpdates, failureReport };
 }
 
-/**
- * Deletes result documents from a previous category location.
- */
+async function writeSingleResult(result, docRef, name, dateContext, logger, config, deps) {
+    const strategies = [ { bytes: 900 * 1024, keys: null }, { bytes: 450 * 1024, keys: 10000 }, { bytes: 200 * 1024, keys: 2000 } ];
+    let committed = false; let lastError = null; let finalStats = { totalSize: 0, isSharded: false, shardCount: 1 };
+
+    for (let attempt = 0; attempt < strategies.length; attempt++) {
+        if (committed) break;
+        const constraints = strategies[attempt];
+        try {
+            const updates = await prepareAutoShardedWrites(result, docRef, logger, constraints.bytes, constraints.keys);
+            const pointer = updates.find(u => u.data._completed === true);
+            finalStats.isSharded = pointer && pointer.data._sharded === true;
+            finalStats.shardCount = finalStats.isSharded ? (pointer.data._shardCount || 1) : 1;
+            finalStats.totalSize = updates.reduce((acc, u) => acc + (u.data ? JSON.stringify(u.data).length : 0), 0);
+            await commitBatchInChunks(config, deps, updates, `${name}::${dateContext} (Att ${attempt+1})`);
+            if (logger && logger.logStorage) { logger.logStorage(null, name, dateContext, docRef.path, finalStats.totalSize, finalStats.isSharded); }
+            committed = true;
+        } catch (commitErr) {
+            lastError = commitErr;
+            const msg = commitErr.message || '';
+            if (NON_RETRYABLE_ERRORS.includes(commitErr.code)) { logger.log('ERROR', `[SelfHealing] ${name} FATAL error: ${msg}.`); throw commitErr; }
+            if (msg.includes('Transaction too big') || msg.includes('payload is too large') || msg.includes('too many index entries')) { logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} failed attempt ${attempt+1}. Retrying...`, { error: msg }); continue; }
+            else { logger.log('WARN', `[SelfHealing] ${name} on ${dateContext} unknown error. Retrying...`, { error: msg }); }
+        }
+    }
+    if (!committed) { throw { message: `Exhausted sharding strategies for ${name}. Last error: ${lastError?.message}`, stack: lastError?.stack, stage: 'SHARDING_LIMIT_EXCEEDED' }; }
+    return finalStats;
+}
+
 async function deleteOldCalculationData(dateStr, oldCategory, calcName, config, deps) {
     const { db, logger, calculationUtils } = deps;
     const { withRetry } = calculationUtils || { withRetry: (fn) => fn() };
-    
     try {
-        const oldDocRef = db.collection(config.resultsCollection)
-            .doc(dateStr)
-            .collection(config.resultsSubcollection)
-            .doc(oldCategory)
-            .collection(config.computationsSubcollection)
-            .doc(calcName);
-
-        const shardsCol  = oldDocRef.collection('_shards');
+        const oldDocRef = db.collection(config.resultsCollection).doc(dateStr).collection(config.resultsSubcollection).doc(oldCategory).collection(config.computationsSubcollection).doc(calcName);
+        const shardsCol = oldDocRef.collection('_shards');
         const shardsSnap = await withRetry(() => shardsCol.listDocuments(), 'ListOldShards');
-        const batch      = db.batch();
-        let ops          = 0;
-
+        const batch = db.batch(); let ops = 0;
         for (const shardDoc of shardsSnap) { batch.delete(shardDoc); ops++; }
-        batch.delete(oldDocRef);
-        ops++;
-
+        batch.delete(oldDocRef); ops++;
         await withRetry(() => batch.commit(), 'CleanupOldCategory');
-        logger.log('INFO', `[Migration] Cleaned up ${ops} docs for ${calcName} in old category '${oldCategory}'`);
-
-    } catch (e) {
-        logger.log('WARN', `[Migration] Failed to clean up old data for ${calcName}: ${e.message}`);
-    }
+        logger.log('INFO', `[Migration] Cleaned up ${ops} docs for ${calcName} in '${oldCategory}'`);
+    } catch (e) { logger.log('WARN', `[Migration] Failed to clean up ${calcName}: ${e.message}`); }
 }
 
 function calculateFirestoreBytes(value) {
-    if (value === null) return 1;
-    if (value === undefined) return 0;
-    if (typeof value === 'boolean') return 1;
-    if (typeof value === 'number') return 8;
-    if (typeof value === 'string') return Buffer.byteLength(value, 'utf8') + 1;
-    if (value instanceof Date) return 8;
-    if (value.constructor && value.constructor.name === 'DocumentReference') { return Buffer.byteLength(value.path, 'utf8') + 16; }
+    if (value === null) return 1; if (value === undefined) return 0; if (typeof value === 'boolean') return 1; if (typeof value === 'number') return 8; if (typeof value === 'string') return Buffer.byteLength(value, 'utf8') + 1; if (value instanceof Date) return 8; if (value.constructor && value.constructor.name === 'DocumentReference') { return Buffer.byteLength(value.path, 'utf8') + 16; }
     if (Array.isArray(value)) { let sum = 0; for (const item of value) sum += calculateFirestoreBytes(item); return sum; }
-    if (typeof value === 'object') { let sum = 0; for (const k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { sum += (Buffer.byteLength(k, 'utf8') + 1) + calculateFirestoreBytes(value[k]); } } return sum; }
-    return 0;
+    if (typeof value === 'object') { let sum = 0; for (const k in value) { if (Object.prototype.hasOwnProperty.call(value, k)) { sum += (Buffer.byteLength(k, 'utf8') + 1) + calculateFirestoreBytes(value[k]); } } return sum; } return 0;
 }
 
 async function prepareAutoShardedWrites(result, docRef, logger, maxBytes = 900 * 1024, maxKeys = null) {
-    const OVERHEAD_ALLOWANCE     = 20 * 1024;
-    const CHUNK_LIMIT            = maxBytes - OVERHEAD_ALLOWANCE;
-    
-    const totalSize              = calculateFirestoreBytes(result);
-    const docPathSize            = Buffer.byteLength(docRef.path, 'utf8') + 16;
-    
-    const writes                 = [];
-    const shardCollection        = docRef.collection('_shards');
-    let currentChunk             = {};
-    let currentChunkSize         = 0;
-    let currentKeyCount          = 0;
-    let shardIndex               = 0;
+    const OVERHEAD_ALLOWANCE = 20 * 1024; const CHUNK_LIMIT = maxBytes - OVERHEAD_ALLOWANCE;
+    const totalSize = calculateFirestoreBytes(result); const docPathSize = Buffer.byteLength(docRef.path, 'utf8') + 16;
+    const writes = []; const shardCollection = docRef.collection('_shards');
+    let currentChunk = {}; let currentChunkSize = 0; let currentKeyCount = 0; let shardIndex = 0;
 
-    // Fast path: If small enough AND keys are safe
     if (!maxKeys && (totalSize + docPathSize) < CHUNK_LIMIT) {  
-        const data = { 
-            ...result, 
-            _completed: true, 
-            _sharded: false,
-            _lastUpdated: new Date().toISOString() 
-        };  
+        const data = { ...result, _completed: true, _sharded: false, _lastUpdated: new Date().toISOString() };  
         return [{ ref: docRef, data, options: { merge: true } }];  
     }
 
     for (const [key, value] of Object.entries(result)) { 
         if (key.startsWith('_')) continue;
-        const keySize   = Buffer.byteLength(key, 'utf8') + 1;         
-        const valueSize = calculateFirestoreBytes(value);
-        const itemSize  = keySize + valueSize;
-
-        const byteLimitReached = (currentChunkSize + itemSize > CHUNK_LIMIT);
-        const keyLimitReached = (maxKeys && currentKeyCount + 1 >= maxKeys);
-
+        const keySize = Buffer.byteLength(key, 'utf8') + 1; const valueSize = calculateFirestoreBytes(value); const itemSize = keySize + valueSize;
+        const byteLimitReached = (currentChunkSize + itemSize > CHUNK_LIMIT); const keyLimitReached = (maxKeys && currentKeyCount + 1 >= maxKeys);
         if (byteLimitReached || keyLimitReached) { 
             writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });
-            shardIndex++;
-            currentChunk     = {};
-            currentChunkSize = 0;
-            currentKeyCount  = 0;
+            shardIndex++; currentChunk = {}; currentChunkSize = 0; currentKeyCount = 0;
         }
-        currentChunk[key] = value;
-        currentChunkSize += itemSize;
-        currentKeyCount++;
-    }
-
-    if (Object.keys(currentChunk).length > 0) {  
-        writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } });  
+        currentChunk[key] = value; currentChunkSize += itemSize; currentKeyCount++;
     }
+    if (Object.keys(currentChunk).length > 0) { writes.push({ ref: shardCollection.doc(`shard_${shardIndex}`), data: currentChunk, options: { merge: false } }); }
     
-    const pointerData = { 
-        _completed: true, 
-        _sharded: true, 
-        _shardCount: shardIndex + 1, 
-        _lastUpdated: new Date().toISOString() 
-    };
+    const pointerData = { _completed: true, _sharded: true, _shardCount: shardIndex + 1, _lastUpdated: new Date().toISOString() };
     writes.push({ ref: docRef, data: pointerData, options: { merge: false } });
     return writes;
 }

package/functions/computation-system/persistence/StatusRepository.js

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Manages computation status tracking in Firestore.
- * UPDATED: Supports Schema V2 (Object with Category) for smart migrations.
+ * UPDATED: Supports Schema V2 (Object with Category & Composition) for deep auditing.
  */
 
 async function fetchComputationStatus(dateStr, config, { db }) {
@@ -14,8 +14,11 @@ async function fetchComputationStatus(dateStr, config, { db }) {
 
     // Normalize V1 (String) to V2 (Object)
     for (const [name, value] of Object.entries(rawData)) {
-        if (typeof value === 'string') { normalized[name] = { hash: value, category: null }; // Legacy entry
-        } else { normalized[name] = value; }
+        if (typeof value === 'string') { 
+            normalized[name] = { hash: value, category: null, composition: null }; // Legacy entry
+        } else { 
+            normalized[name] = value; 
+        }
     }
 
     return normalized;
@@ -30,8 +33,16 @@ async function updateComputationStatus(dateStr, updates, config, { db }) {
     
     const safeUpdates = {};
     for (const [key, val] of Object.entries(updates)) {
-        if (typeof val === 'string') { safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
-        } else { safeUpdates[key] = { ...val, lastUpdated: new Date() }; }
+        if (typeof val === 'string') { 
+            // Legacy Call Fallback
+            safeUpdates[key] = { hash: val, category: 'unknown', lastUpdated: new Date() };
+        } else { 
+            // V2 Call: val should contain { hash, category, composition }
+            safeUpdates[key] = { 
+                ...val, 
+                lastUpdated: new Date() 
+            }; 
+        }
     }
 
     await docRef.set(safeUpdates, { merge: true });

package/functions/computation-system/tools/BuildReporter.js

@@ -38,9 +38,6 @@ async function ensureBuildReport(config, dependencies, manifest) {
         
         // Run generation. This function handles writing the 'latest' document with FULL data.
         await generateBuildReport(config, dependencies, manifest, 90, buildId);
-        
-        // [FIX] REMOVED: The redundant write that was overwriting the full report with just metadata.
-        // The generateBuildReport function now serves as the single source of truth for writing 'latest'.
 
     } catch (e) {
         logger.log('ERROR', `[BuildReporter] Auto-run check failed: ${e.message}`);
@@ -57,23 +54,23 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     logger.log('INFO', `[BuildReporter] Generating Build Report: ${buildId} (Scope: ${daysBack} days)...`);
 
     // 1. Determine Date Range
-    const today = new Date();
+    const today     = new Date();
     const startDate = new Date();
     startDate.setDate(today.getDate() - daysBack);
     
     const datesToCheck = getExpectedDateStrings(startDate, today);
-    const manifestMap = new Map(manifest.map(c => [normalizeName(c.name), c]));
+    const manifestMap  = new Map(manifest.map(c => [normalizeName(c.name), c]));
     
     const reportData = {
         buildId,
-        packageVersion: packageVersion, // [FIX] Renamed 'version' to 'packageVersion' for consistency with ensureBuildReport check
+        packageVersion: packageVersion, 
         generatedAt: new Date().toISOString(),
         summary: {},
         dates: {}
     };
 
     let totalReRuns = 0;
-    let totalNew = 0;
+    let totalNew    = 0;
 
     // 2. PARALLEL PROCESSING
     const limit = pLimit(20);
@@ -106,20 +103,17 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
             // If we fetched prevStatus, it's at index 2
             const prevDailyStatus = (prevDateStr && results[2]) ? results[2] : (prevDateStr ? {} : null);
 
-            const rootDataStatus = availability ? availability.status : {
-                hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false
-            };
+            const rootDataStatus = availability ? availability.status : { hasPortfolio: false, hasHistory: false, hasSocial: false, hasInsights: false, hasPrices: false };
 
             // D. Run Logic Analysis
             const analysis = analyzeDateExecution(dateStr, manifest, rootDataStatus, dailyStatus, manifestMap, prevDailyStatus);
 
             // E. Format Findings
-            const dateSummary = {
-                willRun: [], willReRun: [], blocked: [], impossible: [] 
-            };
+            const dateSummary = { willRun: [], willReRun: [], blocked: [], impossible: [] };
 
+            // Pass the generated "Reason" string through to the report
             analysis.runnable.forEach   (item => dateSummary.willRun.push    ({ name: item.name, reason: "New / No Previous Record" }));
-            analysis.reRuns.forEach     (item => dateSummary.willReRun.push  ({ name: item.name, reason: item.previousCategory ? "Migration" : "Hash Mismatch" }));
+            analysis.reRuns.forEach     (item => dateSummary.willReRun.push  ({ name: item.name, reason: item.reason || "Hash Mismatch" }));
             analysis.impossible.forEach (item => dateSummary.impossible.push ({ name: item.name, reason: item.reason }));
             [...analysis.blocked, ...analysis.failedDependency].forEach(item => dateSummary.blocked.push({ name: item.name, reason: item.reason || 'Dependency' }));
 
@@ -156,11 +150,7 @@ async function generateBuildReport(config, dependencies, manifest, daysBack = 90
     await reportRef.set(reportData);
 
     // 5. Update 'latest' pointer
-    // This now writes the FULL reportData, making 'latest' a cache of the actual report.
-    await db.collection('computation_build_records').doc('latest').set({
-        ...reportData,
-        note: "Latest build report pointer."
-    });
+    await db.collection('computation_build_records').doc('latest').set({ ...reportData, note: "Latest build report pointer." });
 
     logger.log('SUCCESS', `[BuildReporter] Report ${buildId} saved. Re-runs: ${totalReRuns}, New: ${totalNew}.`);