bulltrackers-module 1.0.996 → 1.0.997

package/functions/computation-system-v3/framework/docs/authoring/sample-computations/grade1-portfolio-summary.js

@@ -1,93 +1,108 @@
 /**
- * Grade 1 sample computation — Daily portfolio value summary.
+ * Grade 1 sample computation — basic per‑user portfolio snapshot using SDK helpers.
  *
- * This is a deliberately small, linear example that shows:
- *   - How to declare a minimal `config` for a user computation.
- *   - How to read from `ctx.data` using the keys defined in `config.requires`.
- *   - How to log a short, human-readable trace line via `ctx.log`.
- *   - How to return a safe, envelope-compatible result object (no reserved keys).
+ * This is intentionally the smallest realistic example of a V3 computation:
+ *   - Minimal `config`: only `name`, `type`, and `storage`.
+ *   - No manual `config.requires`: the engine infers it from the code using
+ *     DataContracts (`__contracts`) attached to `lib.*` helpers.
+ *   - Straight‑line `process(ctx)` that reads a single table and returns a
+ *     small, envelope‑compatible result object.
  *
- * The goal is to be a "perfect role model" for new authors, not to be clever.
+ * It is designed to be copied, modified, and extended by users.
  */
 
 /**
  * Configuration object for the computation.
  *
- * - `name` is globally unique per tenant and used in scheduling / storage paths.
- * - `skills: ['lib']` enables read-only helper libraries on `ctx.lib` (not used here,
- *   but included so users see the recommended default).
- * - `requires.portfolio_snapshots` declares the data this computation expects:
- *   a recent window of portfolio snapshots with `date` + `total_value` fields.
- * - `storage.bigquery: true` means the framework will persist results to BigQuery
- *   under the standard `computations` dataset for this tenant.
+ * - `name` is unique per tenant and is used for scheduling and storage paths.
+ * - `type: 'per-entity'` means the computation runs once per entity ID
+ *   (e.g. once per signed‑in user or PI, depending on the calling DAG).
+ * - `storage.bigquery: true` persists the result into the standard
+ *   `computation_results_v3` dataset for this tenant.
+ *
+ * NOTE: We deliberately do NOT define `config.requires` here. The engine
+ * analyses the code in `process(ctx)` and infers a safe `requires` block
+ * from the `ctx.lib.portfolio.*` calls and `ctx.data.portfolio_snapshots`
+ * access (see `docs/authoring/config-resolution.md`).
  */
 exports.config = {
-    name: 'Sample_PortfolioDailySummary_Grade1',
-    skills: ['lib'],
-    lib: [],
-    requires: {
-        portfolio_snapshots: {
-            // The runtime will fetch up to 7 days of snapshots ending at ctx.date.
-            lookback: 7,
-            mandatory: true,
-            fields: ['date', 'total_value']
-        }
-    },
+    name: 'Sample_PortfolioSnapshot_Grade1',
+    type: 'per-entity',
+    category: 'examples',
     storage: {
         bigquery: true
     }
 };
 
 /**
- * Process function — called by the runtime for a single execution target.
+ * Process function — summarises the latest portfolio snapshot for one entity.
  *
- * Signature:
- *   - ctx.computation: string  → the value of config.name.
- *   - ctx.date: string         → ISO date (YYYY-MM-DD) the run is targeting.
- *   - ctx.data: object         → data fetched according to `config.requires`.
- *   - ctx.log: (message) => void → structured log helper scoped to this computation.
+ * For the current `entityId` and `date`, this function:
+ *   1. Uses `lib.dataHelpers.getEntityRows` to get rows from
+ *      `ctx.data.portfolio_snapshots` that belong to the current entity.
+ *   2. Sorts those rows by date ascending using `lib.dataHelpers.sortByDateAsc`.
+ *   3. Extracts the latest `portfolio_data` payload via `lib.portfolio.extractPortfolioData`.
+ *   4. Derives simple metrics using `lib.portfolio` helpers:
+ *        - `calculateTotalInvested`
+ *        - `calculateTotalValue`
+ *        - `calculateWinRatio`
+ *   5. Returns a compact result object with no reserved keys (`status`, `error`).
  *
- * Behaviour:
- *   1. Read the `portfolio_snapshots` array from ctx.data.
- *   2. Filter out rows that do not have a finite numeric `total_value`.
- *   3. Compute a simple count and average total value over the window.
- *   4. Log a short summary line with the number of snapshots analysed.
- *   5. Return a result object with:
- *        - outcome: high-level status code for domain logic ("OK" or "NO_DATA").
- *        - asOfDate: the target date for the run.
- *        - snapshotCount: how many rows were actually used.
- *        - averagePortfolioValue: null if there was no valid data.
+ * This pattern matches how production computations in `../computations` use the SDK.
+ *
+ * @param {import('../core/ContextBuilder').ComputationContext} ctx
  */
 exports.process = function process(ctx) {
-    const snapshots = Array.isArray(ctx.data && ctx.data.portfolio_snapshots)
-        ? ctx.data.portfolio_snapshots
-        : [];
+    const { data, entityId, date, lib, log } = ctx;
+
+    const rows = lib.dataHelpers.getEntityRows(data['portfolio_snapshots'], entityId);
+    const sorted = lib.dataHelpers.sortByDateAsc(rows);
+    const latest = sorted.length > 0 ? sorted[sorted.length - 1] : null;
 
-    const numericValues = [];
-    for (const row of snapshots) {
-        const raw = row && row.total_value;
-        const value = typeof raw === 'number' ? raw : Number(raw);
-        if (Number.isFinite(value)) {
-            numericValues.push(value);
+    if (!latest) {
+        if (log) {
+            log(
+                `[Sample_PortfolioSnapshot_Grade1] No portfolio_snapshots rows for entity ${String(
+                    entityId
+                )} on ${date}`
+            );
         }
+
+        return {
+            outcome: 'NO_DATA',
+            asOfDate: date,
+            entityId: entityId ?? null,
+            totalInvested: 0,
+            totalValue: 0,
+            winRatioPercent: 0
+        };
     }
 
-    const snapshotCount = numericValues.length;
-    const averagePortfolioValue =
-        snapshotCount === 0
-            ? null
-            : numericValues.reduce((sum, value) => sum + value, 0) / snapshotCount;
+    const portfolioData = lib.portfolio.extractPortfolioData(latest);
+    const positions = lib.portfolio.extractPositions(portfolioData);
+
+    const totalInvested = lib.portfolio.calculateTotalInvested(positions);
+    const totalValue = lib.portfolio.calculateTotalValue(positions);
+    const winRatioPercent = lib.portfolio.calculateWinRatio(positions);
 
-    ctx.log(
-        `[Sample_PortfolioDailySummary_Grade1] analysed ${snapshotCount} snapshot(s) for ${ctx.date}`
-    );
+    if (log) {
+        log(
+            `[Sample_PortfolioSnapshot_Grade1] entity=${String(
+                entityId
+            )} invested=${totalInvested.toFixed(2)} value=${totalValue.toFixed(
+                2
+            )} winRatio=${winRatioPercent.toFixed(2)}%`
+        );
+    }
 
     return {
-        // Use a domain-level outcome key; never use reserved keys like `status` or `error`.
-        outcome: snapshotCount === 0 ? 'NO_DATA' : 'OK',
-        asOfDate: ctx.date,
-        snapshotCount,
-        averagePortfolioValue
+        // Domain‑level outcome; do not use reserved keys like `status` or `error`.
+        outcome: 'OK',
+        asOfDate: date,
+        entityId: entityId ?? null,
+        totalInvested: Number(totalInvested.toFixed(2)),
+        totalValue: Number(totalValue.toFixed(2)),
+        winRatioPercent: Number(winRatioPercent.toFixed(2))
     };
 };
 

package/functions/computation-system-v3/framework/docs/authoring/sample-computations/grade2-entity-risk-change.js

@@ -1,145 +1,116 @@
 /**
- * Grade 2 sample computation — Per-entity risk change over a rolling window.
+ * Grade 2 sample computation — PI risk and AUM summary over a short window.
  *
- * This example builds on the Grade 1 sample by:
- *   - Operating in a clearly per-entity way (each entity is evaluated independently).
- *   - Working with two logical inputs (`risk_snapshots` and `portfolio_snapshots`).
- *   - Computing a small derived metric (risk delta) per entity.
- *   - Demonstrating safe handling of missing / partial data.
+ * This example builds directly on the real `pi_rankings` table and uses the
+ * `lib.rankings` and `lib.dataHelpers` modules exactly as production recipes do.
  *
- * It is still intentionally linear and readable; the comments explain each step so that
- * new authors can copy this pattern when adding their own logic.
+ * It demonstrates:
+ *   - Per‑entity operation (`type: 'per-entity'` for PI entities).
+ *   - A small but explicit `config.requires` override to control lookback,
+ *     fields, and mandatory flags.
+ *   - Safe handling of missing data across days.
  */
 
 /**
  * Configuration object for the computation.
  *
- * - `name` uniquely identifies this computation.
- * - `type: 'per-entity'` tells the runtime to run once per entity (e.g. per portfolio).
- * - `requires.risk_snapshots` and `requires.portfolio_snapshots` declare the inputs.
- * - `storage.bigquery: true` persists the result into tenant-scoped BigQuery tables.
+ * - `name` and `type` follow the same pattern as `RiskScoreIncrease`.
+ * - `requires.pi_rankings` is kept intentionally small but explicit so the
+ *   author can see and tune lookback/fields in one place.
+ * - `storage.bigquery: true` persists results for later dashboard use.
  */
 exports.config = {
-    name: 'Sample_EntityRiskChange_Grade2',
+    name: 'Sample_PIRiskAndAum_Grade2',
     type: 'per-entity',
-    skills: ['lib'],
-    lib: [],
+    category: 'examples',
+
     requires: {
-        risk_snapshots: {
-            // 30-day lookback window of per-entity risk scores.
-            lookback: 30,
-            mandatory: true,
-            fields: ['date', 'entity_id', 'risk_score']
-        },
-        portfolio_snapshots: {
-            // Optional: we only need a name/label for display purposes.
-            lookback: 1,
+        pi_rankings: {
+            // 7‑day window of rankings for this PI, similar to DashboardPage.
+            lookback: 7,
             mandatory: false,
-            fields: ['entity_id', 'display_name']
+            fields: ['pi_id', 'rankings_data', 'username', 'date']
         }
     },
+
     storage: {
         bigquery: true
     }
 };
 
 /**
- * Process function — computes the change in risk score for a single entity.
+ * Process function — summarises basic risk and AUM information for a single PI.
+ *
+ * For each PI (`entityId`) this function:
+ *   1. Pulls that PI's `pi_rankings` rows via `lib.dataHelpers.getEntityRows`.
+ *   2. Sorts the rows by date, then picks the latest one in the lookback window.
+ *   3. Uses `lib.rankings` helpers to extract:
+ *        - current risk score and risk tier,
+ *        - total gain,
+ *        - AUM value and tier label.
+ *   4. Returns a compact result object, suitable for direct consumption by
+ *      dashboards or downstream computations.
  *
- * For each entity on a given date:
- *   1. Filter the `risk_snapshots` array down to the current entityId (if provided).
- *   2. Sort snapshots by date to find the "previous" and "current" entries.
- *   3. Compute a simple delta: current_risk - previous_risk.
- *   4. Look up a human-readable portfolio name from `portfolio_snapshots` if present.
- *   5. Return a single object that describes today's risk position for this entity.
+ * @param {import('../core/ContextBuilder').ComputationContext} ctx
  */
 exports.process = function process(ctx) {
-    const entityId = ctx.entityId;
+    const { data, entityId, date, lib, log } = ctx;
 
-    const allRiskSnapshots = Array.isArray(ctx.data && ctx.data.risk_snapshots)
-        ? ctx.data.risk_snapshots
-        : [];
+    const rows = lib.dataHelpers.getEntityRows(data['pi_rankings'], entityId);
+    const sorted = lib.dataHelpers.sortByDateAsc(rows);
+    const latest = sorted.length > 0 ? sorted[sorted.length - 1] : null;
 
-    // Step 1: isolate this entity's rows (or all rows if entityId is not provided).
-    const entityRiskRows = allRiskSnapshots.filter((row) => {
-        if (!row) return false;
-        if (entityId == null) return true;
-        return String(row.entity_id) === String(entityId);
-    });
-
-    // Step 2: sort by date ascending so the last element is the most recent snapshot.
-    entityRiskRows.sort((a, b) => {
-        const ad = a && a.date ? String(a.date) : '';
-        const bd = b && b.date ? String(b.date) : '';
-        return ad.localeCompare(bd);
-    });
-
-    const rowCount = entityRiskRows.length;
-    if (rowCount === 0) {
-        ctx.log(
-            `[Sample_EntityRiskChange_Grade2] no risk_snapshots found for entity ${String(
-                entityId || 'GLOBAL'
-            )} on ${ctx.date}`
-        );
+    if (!latest) {
+        if (log) {
+            log(
+                `[Sample_PIRiskAndAum_Grade2] No pi_rankings rows for entity ${String(
+                    entityId
+                )} in window ending ${date}`
+            );
+        }
 
         return {
             outcome: 'NO_DATA',
-            asOfDate: ctx.date,
-            entityId: entityId || null,
-            currentRisk: null,
-            previousRisk: null,
-            riskDelta: null
+            asOfDate: date,
+            entityId: entityId ?? null,
+            username: null,
+            riskScore: null,
+            riskTier: null,
+            totalGain: null,
+            aumValue: null,
+            aumTierLabel: null
         };
     }
 
-    const latest = entityRiskRows[rowCount - 1];
-    const previous = rowCount > 1 ? entityRiskRows[rowCount - 2] : null;
-
-    const currentRisk =
-        latest && typeof latest.risk_score === 'number'
-            ? latest.risk_score
-            : Number(latest && latest.risk_score);
-    const previousRisk =
-        previous && typeof previous.risk_score === 'number'
-            ? previous.risk_score
-            : Number(previous && previous.risk_score);
+    const rankingsData = lib.rankings.extractRankingsData(latest);
+    const username = lib.rankings.getUsername(latest);
 
-    const safeCurrent = Number.isFinite(currentRisk) ? currentRisk : null;
-    const safePrevious = Number.isFinite(previousRisk) ? previousRisk : null;
+    const riskScore = lib.rankings.getRiskScore(rankingsData);
+    const riskTier = lib.rankings.getRiskTier(riskScore);
 
-    let riskDelta = null;
-    if (safeCurrent != null && safePrevious != null) {
-        riskDelta = safeCurrent - safePrevious;
-    }
+    const totalGain = lib.rankings.getTotalGain(rankingsData);
+    const aumValue = lib.rankings.getAUM(rankingsData);
+    const aumTierId = lib.rankings.getAUMTier(rankingsData);
+    const aumTierLabel = lib.rankings.getAUMTierLabel(aumTierId);
 
-    // Optional: look up a display name from portfolio_snapshots for nicer reporting.
-    let portfolioName = null;
-    const portfolioRows = Array.isArray(ctx.data && ctx.data.portfolio_snapshots)
-        ? ctx.data.portfolio_snapshots
-        : [];
-    const matchingPortfolio = portfolioRows.find((row) => {
-        if (!row) return false;
-        if (entityId == null) return false;
-        return String(row.entity_id) === String(entityId);
-    });
-    if (matchingPortfolio && typeof matchingPortfolio.display_name === 'string') {
-        portfolioName = matchingPortfolio.display_name;
+    if (log) {
+        log(
+            `[Sample_PIRiskAndAum_Grade2] entity=${String(
+                entityId
+            )} risk=${riskScore} (${riskTier}), AUM=${aumValue}, gain=${totalGain}`
+        );
     }
 
-    ctx.log(
-        `[Sample_EntityRiskChange_Grade2] entity ${String(
-            entityId || 'GLOBAL'
-        )} risk=${safeCurrent} (delta=${riskDelta}) on ${ctx.date}`
-    );
-
     return {
         outcome: 'OK',
-        asOfDate: ctx.date,
-        entityId: entityId || null,
-        portfolioName,
-        currentRisk: safeCurrent,
-        previousRisk: safePrevious,
-        riskDelta
+        asOfDate: date,
+        entityId: entityId ?? null,
+        username: username || null,
+        riskScore,
+        riskTier,
+        totalGain,
+        aumValue,
+        aumTierLabel
     };
 };
 

package/functions/computation-system-v3/framework/docs/authoring/sample-computations/grade3-alert-on-risk-spike.js

@@ -1,102 +1,162 @@
 /**
- * Grade 3 sample computation — Simple alert surface for risk spikes.
+ * Grade 3 sample computation — asset + PI risk alerts (composed from real tables).
  *
- * This example is intentionally still single-file and easy to read, but it
- * shows a slightly more "production-like" pattern:
- *   - It depends on the Grade 2 computation's result by name via `dependencies`.
- *   - It treats the upstream result as an input table in `requires`.
- *   - It emits a compact list of "alerts" that could be consumed by downstream
- *     dashboards or notification systems.
+ * This example shows an end‑to‑end, production‑style pattern:
+ *   - Depends on the existing `GlobalAumPerAsset30D` computation so it runs first.
+ *   - Reads its materialised results from the `results` table via data helpers.
+ *   - Combines that with live `pi_rankings` data to build two alert feeds:
+ *       • high‑AUM assets
+ *       • high‑risk, high‑AUM Popular Investors
  *
- * This is not wired into any real alerting system; it is a didactic example
- * that demonstrates how to compose computations safely.
+ * The intent is to be a “perfect role model”: everything is grounded in the
+ * current framework, no invented tables, and every step is documented.
  */
 
 /**
- * Configuration object for the computation.
+ * Configuration for the computation.
  *
- * - `dependencies` lists another computation by name. The planner ensures that
- *   the dependency runs first for the target date / entity set before this one.
- * - `requires.entity_risk_change` models the dependency's output as a table-like
- *   input; in a real deployment this would be backed by storage (e.g. BigQuery).
+ * Key points:
+ *   - `type: 'global'` because we aggregate across all entities.
+ *   - `dependencies` ensures `GlobalAumPerAsset30D` has written its output to
+ *     the `results` table before this computation runs.
+ *   - `requires.results` explicitly filters that table to only the parent
+ *     computation’s rows, mirroring `GlobalAumPerAsset30D`.
+ *   - `requires.pi_rankings` gives us current PI risk/AUM data for scoring.
  */
 exports.config = {
-    name: 'Sample_RiskSpikeAlerts_Grade3',
-    skills: ['lib'],
-    lib: [],
-    dependencies: ['Sample_EntityRiskChange_Grade2'],
+    name: 'Sample_AssetAndRiskAlerts_Grade3',
+    type: 'global',
+    category: 'examples',
+
+    // Ensure the upstream aggregation has run before this computation executes.
+    dependencies: ['globalaumperasset30d'],
+
     requires: {
-        entity_risk_change: {
-            // The runtime will typically resolve this from the dependency's output.
-            lookback: 1,
+        // Parent computation results, constrained to GlobalAumPerAsset30D.
+        results: {
+            lookback: 0,
             mandatory: true,
-            fields: [
-                'asOfDate',
-                'entityId',
-                'portfolioName',
-                'currentRisk',
-                'previousRisk',
-                'riskDelta'
-            ]
+            fields: ['result_data', 'computation_name', 'date', 'entity_id'],
+            filter: { computation_name: 'globalaumperasset30d' }
+        },
+        // Current PI rankings window; used to identify high‑risk, high‑AUM PIs.
+        pi_rankings: {
+            lookback: 7,
+            mandatory: false,
+            fields: ['pi_id', 'rankings_data', 'username', 'date']
         }
     },
+
     storage: {
         bigquery: true
     }
 };
 
 /**
- * Process function — builds a list of simple alert objects when risk jumps.
+ * Process function — produces alert lists for assets and PIs.
+ *
+ * High‑level behaviour:
+ *
+ *   1. Reads `results` for `GlobalAumPerAsset30D` using:
+ *        - `lib.dataHelpers.normaliseParentResults` to flatten rows
+ *        - `lib.dataHelpers.parseResultData` to parse `result_data`
+ *      and emits **asset AUM alerts** where total AUM exceeds a fixed threshold.
  *
- * Behaviour:
- *   1. Read the `entity_risk_change` rows for the current date.
- *   2. Filter to entities whose absolute riskDelta is above a fixed threshold.
- *   3. Map each row to a small, explicit alert object.
- *   4. Return a payload containing:
- *        - outcome: "OK" or "NO_ALERTS".
- *        - asOfDate: the date we evaluated.
- *        - alerts: array of alert objects (possibly empty).
+ *   2. Reads `pi_rankings` via `lib.dataHelpers.toArray` and `lib.rankings`
+ *      helpers to construct **PI risk alerts** for Popular Investors that are
+ *      both high‑risk and above a minimum AUM tier.
  *
- * NOTE: This computation does not send notifications itself; it produces clean,
- * queryable data that other systems can use as a source of truth.
+ *   3. Returns a single, envelope‑compatible result object:
+ *        - `outcome`: `"OK"` or `"NO_ALERTS"`
+ *        - `asOfDate`: target date
+ *        - `assetAlerts`: array of asset‑level alerts
+ *        - `piRiskAlerts`: array of PI‑level alerts
+ *
+ * @param {import('../core/ContextBuilder').ComputationContext} ctx
  */
 exports.process = function process(ctx) {
-    const rows = Array.isArray(ctx.data && ctx.data.entity_risk_change)
-        ? ctx.data.entity_risk_change
-        : [];
+    const { data, date, lib, log } = ctx;
+
+    const { normaliseParentResults, parseResultData, toArray } = lib.dataHelpers;
+
+    // -------------------------------------------------------------------------
+    // 1. Asset‑level alerts from GlobalAumPerAsset30D parent results
+    // -------------------------------------------------------------------------
+    const parentRows = normaliseParentResults(data['results']);
+    const assetAlerts = [];
+
+    // Example threshold: only alert on assets with at least 50k AUM.
+    const ASSET_AUM_THRESHOLD = 50000;
 
-    const THRESHOLD = 5; // Example threshold for a "meaningful" risk move.
+    for (const row of parentRows) {
+        const parsed = parseResultData(row) || row;
 
-    const alerts = [];
-    for (const row of rows) {
-        if (!row) continue;
+        // GlobalAumPerAsset30D returns an array of { symbol, amount } entries
+        // as its top‑level `result`. We tolerate both raw arrays and envelopes.
+        const items = Array.isArray(parsed)
+            ? parsed
+            : (Array.isArray(parsed.result) ? parsed.result : []);
 
-        const delta = row.riskDelta;
-        if (!Number.isFinite(delta)) continue;
+        for (const item of items) {
+            if (!item || item.symbol == null || item.amount == null) continue;
+            const amount = Number(item.amount);
+            if (!Number.isFinite(amount) || amount < ASSET_AUM_THRESHOLD) continue;
 
-        if (Math.abs(delta) < THRESHOLD) {
-            continue;
+            assetAlerts.push({
+                type: 'ASSET_AUM',
+                symbol: item.symbol,
+                amount: Number(amount.toFixed(2)),
+                asOfDate: date
+            });
         }
+    }
+
+    // -------------------------------------------------------------------------
+    // 2. PI‑level risk alerts from pi_rankings
+    // -------------------------------------------------------------------------
+    const rankings = toArray(data['pi_rankings'] || []);
+    const piRiskAlerts = [];
+
+    // Example policy: alert on "high" or above risk and mid‑tier AUM or higher.
+    const MIN_RISK_SCORE = 6;
+    const MIN_AUM_TIER = 3;
+
+    rankings.forEach((row) => {
+        const rData = lib.rankings.extractRankingsData(row);
+        if (!rData) return;
+
+        const riskScore = lib.rankings.getRiskScore(rData);
+        const riskTier = lib.rankings.getRiskTier(riskScore);
+        const aumValue = lib.rankings.getAUM(rData);
+        const aumTierId = lib.rankings.getAUMTier(rData);
 
-        alerts.push({
-            entityId: row.entityId || null,
-            portfolioName: typeof row.portfolioName === 'string' ? row.portfolioName : null,
-            asOfDate: row.asOfDate || ctx.date,
-            currentRisk: Number.isFinite(row.currentRisk) ? row.currentRisk : null,
-            previousRisk: Number.isFinite(row.previousRisk) ? row.previousRisk : null,
-            riskDelta: delta,
-            direction: delta > 0 ? 'INCREASE' : 'DECREASE'
+        if (riskScore < MIN_RISK_SCORE || aumTierId < MIN_AUM_TIER) {
+            return;
+        }
+
+        piRiskAlerts.push({
+            type: 'PI_RISK',
+            piId: lib.rankings.getPiId(row),
+            username: lib.rankings.getUsername(row),
+            riskScore,
+            riskTier,
+            aumValue,
+            aumTierLabel: lib.rankings.getAUMTierLabel(aumTierId)
         });
-    }
+    });
 
-    ctx.log(
-        `[Sample_RiskSpikeAlerts_Grade3] generated ${alerts.length} alert(s) for ${ctx.date} with threshold ${THRESHOLD}`
-    );
+    if (log) {
+        log(
+            `[Sample_AssetAndRiskAlerts_Grade3] generated ${assetAlerts.length} asset alert(s) and ${piRiskAlerts.length} PI risk alert(s) for ${date}`
+        );
+    }
 
     return {
-        outcome: alerts.length === 0 ? 'NO_ALERTS' : 'OK',
-        asOfDate: ctx.date,
-        alerts
+        // Use a domain‑level outcome; never return reserved keys `status` or `error`.
+        outcome: assetAlerts.length === 0 && piRiskAlerts.length === 0 ? 'NO_ALERTS' : 'OK',
+        asOfDate: date,
+        assetAlerts,
+        piRiskAlerts
     };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.996",
+  "version": "1.0.997",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [