og-graph 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# og-graph
+
+> Descripción del paquete
+
+## Instalación
+
+```bash
+npm install og-graph
+```
+
+## Uso
+
+```js
+const { hello } = require('og-graph');
+
+hello('world'); // "Hello, world!"
+```
+
+## API
+
+### `hello(name)`
+
+Descripción de la función.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "og-graph",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./src/index.js",
+  "scripts": {
+    "test": "node test/index.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/activitySignals.cjs

@@ -0,0 +1,289 @@
+// activitySignals.cjs
+function clamp(n, a, b) {
+  return Math.max(a, Math.min(b, n));
+}
+function mean(arr) {
+  if (!arr || !arr.length) return 0;
+  let s = 0;
+  for (const x of arr) s += x;
+  return s / arr.length;
+}
+
+function smoothSeries(series, radius = 2) {
+  const n = series.length;
+  const out = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    const a = Math.max(0, i - radius);
+    const b = Math.min(n - 1, i + radius);
+    let s = 0, c = 0;
+    for (let k = a; k <= b; k++) { s += series[k]; c++; }
+    out[i] = c ? s / c : series[i];
+  }
+  return out;
+}
+
+function resampleGraphPoints(graphPoints, maxMinute = 90) {
+  const pts = [...(graphPoints || [])].sort((a, b) => a.minute - b.minute);
+  const series = new Array(maxMinute + 1).fill(0);
+  let j = 0, last = 0;
+  for (let m = 0; m <= maxMinute; m++) {
+    while (j < pts.length && pts[j].minute <= m) {
+      last = Number(pts[j].value) || 0;
+      j++;
+    }
+    series[m] = last;
+  }
+  return series;
+}
+
+function totalPressureFromSmooth(smooth) {
+  let home = 0, away = 0;
+  for (const v of smooth) {
+    if (v > 0) home += v;
+    else away += -v;
+  }
+  return { home, away, total: home + away };
+}
+
+function detectPhases(smooth, T = 10) {
+  const phases = [];
+  let cur = null;
+
+  function teamFrom(v) {
+    if (v > T) return "home";
+    if (v < -T) return "away";
+    return "neutral";
+  }
+
+  for (let m = 0; m < smooth.length; m++) {
+    const t = teamFrom(smooth[m] || 0);
+    if (!cur) cur = { team: t, start: m, end: m };
+    else if (t === cur.team) cur.end = m;
+    else {
+      phases.push(cur);
+      cur = { team: t, start: m, end: m };
+    }
+  }
+  if (cur) phases.push(cur);
+
+  return phases.map(p => {
+    const slice = smooth.slice(p.start, p.end + 1);
+    const avg = mean(slice);
+    const peakAbs = slice.reduce((mx, v) => Math.max(mx, Math.abs(v)), 0);
+    return {
+      team: p.team,
+      start: p.start,
+      end: p.end,
+      duration: p.end - p.start + 1,
+      mean: avg,
+      intensity: Math.abs(avg),
+      peakAbs
+    };
+  });
+}
+
+function buildScoreTimeline(goals, maxMinute) {
+  const g = [...(goals || [])].sort((a, b) => a.minute - b.minute);
+  const out = Array.from({ length: maxMinute + 1 }, () => ({ home: 0, away: 0 }));
+  let h = 0, a = 0, j = 0;
+  for (let m = 0; m <= maxMinute; m++) {
+    while (j < g.length && g[j].minute <= m) {
+      if (g[j].team === "home") h++;
+      else if (g[j].team === "away") a++;
+      j++;
+    }
+    out[m] = { home: h, away: a };
+  }
+  return out;
+}
+
+function stateFromScore(sc) {
+  if (sc.home > sc.away) return "home_leading";
+  if (sc.away > sc.home) return "away_leading";
+  return "draw";
+}
+
+function gameStateImpact(smooth, scoreTimeline) {
+  const buckets = {
+    home_leading: { home: 0, away: 0, minutes: 0 },
+    away_leading: { home: 0, away: 0, minutes: 0 },
+    draw:         { home: 0, away: 0, minutes: 0 }
+  };
+
+  const maxM = Math.min(smooth.length - 1, scoreTimeline.length - 1);
+  for (let m = 1; m <= maxM; m++) {
+    const state = stateFromScore(scoreTimeline[m]);
+    const v = smooth[m] || 0;
+    if (v > 0) buckets[state].home += v;
+    else buckets[state].away += -v;
+    buckets[state].minutes += 1;
+  }
+
+  const out = {};
+  for (const [k, b] of Object.entries(buckets)) {
+    out[k] = {
+      minutes: b.minutes,
+      homePerMin: b.minutes ? b.home / b.minutes : 0,
+      awayPerMin: b.minutes ? b.away / b.minutes : 0
+    };
+  }
+  return out;
+}
+
+function leadFragilityMinutes(smooth, scoreTimeline, T = 10) {
+  const maxMinute = Math.min(smooth.length - 1, scoreTimeline.length - 1);
+  let homeFrag = 0, awayFrag = 0;
+
+  for (let m = 1; m <= maxMinute; m++) {
+    const sc = scoreTimeline[m];
+    const v = smooth[m] || 0;
+    if (sc.home > sc.away && v < -T) homeFrag++;
+    if (sc.away > sc.home && v > T) awayFrag++;
+  }
+  return { homeLeadingButDominatedMinutes: homeFrag, awayLeadingButDominatedMinutes: awayFrag };
+}
+
+function volatilityIndex(smooth, volT = 12) {
+  let flips = 0;
+  let last = 0; // -1 away, +1 home, 0 neutral
+  for (let m = 1; m < smooth.length; m++) {
+    const v = smooth[m] || 0;
+    const side = v > volT ? 1 : v < -volT ? -1 : 0;
+    if (side !== 0 && last !== 0 && side !== last) flips++;
+    if (side !== 0) last = side;
+  }
+  return { flipsStrong: flips };
+}
+
+// Presión en ventana para alertas live (simple)
+function windowPressure(smooth, m, W = 10) {
+  const a = Math.max(0, m - W);
+  let home = 0, away = 0;
+  for (let k = a; k < m; k++) {
+    const v = smooth[k] || 0;
+    if (v > 0) home += v;
+    else away += -v;
+  }
+  return { home, away };
+}
+
+function buildAlerts(smooth, scoreTimeline, opts = {}) {
+  const W = opts.W ?? 10;
+  const T = opts.T ?? 10;
+  const pressureMin = opts.pressureMin ?? 80;
+  const alerts = [];
+
+  for (let m = 1; m < smooth.length; m++) {
+    const sc = scoreTimeline[m];
+    const v = smooth[m] || 0;
+
+    // lead_fragile
+    if (sc.home !== sc.away) {
+      const leadTeam = sc.home > sc.away ? "home" : "away";
+      const dominatedBy =
+        (leadTeam === "home" && v < -T) ? "away" :
+        (leadTeam === "away" && v > T) ? "home" :
+        null;
+
+      if (dominatedBy) {
+        const wp = windowPressure(smooth, m, W);
+        const domVal = dominatedBy === "home" ? wp.home : wp.away;
+        if (domVal >= pressureMin) {
+          alerts.push({ minute: m, type: "lead_fragile", leadTeam, dominatedBy, windowPressure: wp });
+        }
+      }
+    }
+
+    // late_goal_pressure (70+)
+    if (m >= 70) {
+      const wp = windowPressure(smooth, m, W);
+      const likely =
+        wp.home >= pressureMin && wp.home > wp.away ? "home" :
+        wp.away >= pressureMin && wp.away > wp.home ? "away" :
+        null;
+      if (likely) alerts.push({ minute: m, type: "late_goal_pressure", teamLikely: likely, windowPressure: wp });
+    }
+  }
+
+  // compacta: evita spam igual minuto-tipo
+  const seen = new Set();
+  return alerts.filter(a => {
+    const k = `${a.minute}-${a.type}-${a.teamLikely || a.leadTeam}`;
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+}
+
+// --- Clasificación de goles (mejorada) ---
+function buildPressureAtMinute(smooth, m, W) {
+  const a = Math.max(0, m - W);
+  let home = 0, away = 0;
+  for (let k = a; k < m; k++) {
+    const v = smooth[k] ?? 0;
+    if (v > 0) home += v;
+    else away += -v;
+  }
+  return { home, away };
+}
+
+function meanWindow(smooth, from, toExclusive) {
+  const a = clamp(from, 0, smooth.length);
+  const b = clamp(toExclusive, 0, smooth.length);
+  if (b <= a) return 0;
+  let s = 0, c = 0;
+  for (let i = a; i < b; i++) { s += smooth[i] ?? 0; c++; }
+  return c ? s / c : 0;
+}
+
+function classifyGoal(goal, smooth, opts = {}) {
+  const { minute, team } = goal;
+  const Wshort = opts.Wshort ?? 3;
+  const Wlong  = opts.Wlong  ?? 10;
+
+  const m = clamp(Math.floor(minute), 0, smooth.length - 1);
+
+  const ps = buildPressureAtMinute(smooth, m, Wshort);
+  const pl = buildPressureAtMinute(smooth, m, Wlong);
+
+  const ratioShort = (team === "home" ? ps.home : ps.away) / (ps.home + ps.away + 1e-9);
+  const ratioLong  = (team === "home" ? pl.home : pl.away) / (pl.home + pl.away + 1e-9);
+
+  const label =
+    (ratioShort >= 0.60 && ratioLong >= 0.60) ? "flow" :
+    (ratioShort <= 0.40 && ratioLong <= 0.40) ? "against_flow" :
+    "mixed";
+
+  const preTrend  = meanWindow(smooth, m - Wlong, m);
+  const postTrend = meanWindow(smooth, m + 1, m + 1 + Wlong);
+  const swing = postTrend - preTrend;
+
+  const localShock = Math.abs((smooth[m] ?? 0) - (smooth[m - 1] ?? 0));
+  const absLevel = Math.abs(smooth[m] ?? 0);
+
+  const brokeScript =
+    (Math.sign(preTrend) !== Math.sign(postTrend) && Math.abs(swing) >= (opts.swingT ?? 10)) ||
+    (localShock >= (opts.shockT ?? 20)) ||
+    (absLevel >= (opts.levelT ?? 35));
+
+  return {
+    minute, team,
+    ratioShort, ratioLong, label,
+    preTrend, postTrend, swing,
+    brokeScript,
+    signals: { localShock, absLevel }
+  };
+}
+
+module.exports = {
+  resampleGraphPoints,
+  smoothSeries,
+  totalPressureFromSmooth,
+  detectPhases,
+  buildScoreTimeline,
+  gameStateImpact,
+  leadFragilityMinutes,
+  volatilityIndex,
+  buildAlerts,
+  classifyGoal
+};

package/src/buildMatchAnomaly.cjs

@@ -0,0 +1,145 @@
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function abs(x) { return Math.abs(Number(x) || 0); }
+function r2(x) { return Math.round((Number(x) || 0) * 100) / 100; }
+
+function scoreDiff(finalScore) {
+  const h = finalScore?.home ?? 0;
+  const a = finalScore?.away ?? 0;
+  return h - a;
+}
+
+function winner(finalScore) {
+  const d = scoreDiff(finalScore);
+  return d > 0 ? "home" : d < 0 ? "away" : "draw";
+}
+
+function buildMatchAnomaly(report, opts = {}) {
+  // Pesos recomendados (los que ya vienes usando bien)
+  const W = {
+    fairness: opts.wFairness ?? 0.25,
+    fragility: opts.wFragility ?? 0.35,
+    mismatch: opts.wMismatch ?? 0.15,
+    volatility: opts.wVolatility ?? 0.25
+  };
+
+  const TH = {
+    fairnessStrong: opts.fairnessStrong ?? 0.15,
+    fragStrong: opts.fragStrong ?? 0.45,
+    flipsStrong: opts.flipsStrong ?? 5,
+    xMismatch1: opts.xMismatch1 ?? 0.75,
+    xMismatch2: opts.xMismatch2 ?? 1.25,
+    lateMin: opts.lateMin ?? 75
+  };
+
+  const finalScore = report?.finalScore || { home: 0, away: 0 };
+  const win = winner(finalScore);
+
+  const fairness = Number(report?.fairness ?? 0);
+  const fairnessN = clamp01(abs(fairness) / 0.35);
+
+  const leadMin =
+    (report?.gameStateImpact?.home_leading?.minutes || 0) +
+    (report?.gameStateImpact?.away_leading?.minutes || 0);
+
+  const dominatedWhileLeading =
+    (report?.leadFragility?.homeLeadingButDominatedMinutes || 0) +
+    (report?.leadFragility?.awayLeadingButDominatedMinutes || 0);
+
+  const fragility = leadMin ? dominatedWhileLeading / leadMin : 0;
+  const fragilityN = clamp01(fragility);
+
+  const xh = Number(report?.xScore?.home ?? 0);
+  const xa = Number(report?.xScore?.away ?? 0);
+  const xDiff = xh - xa;
+  const realDiff = scoreDiff(finalScore);
+  const mismatch = abs(xDiff - realDiff);
+  const mismatchN = clamp01((mismatch - TH.xMismatch1) / (TH.xMismatch2 - TH.xMismatch1));
+
+  const flips = Number(report?.volatility?.flipsStrong ?? 0);
+  const volatilityN = clamp01(flips / 10);
+
+  const MAI01 =
+    W.fairness * fairnessN +
+    W.fragility * fragilityN +
+    W.mismatch * mismatchN +
+    W.volatility * volatilityN;
+
+  const flags = [];
+
+  const dominantSide = fairness > 0 ? "home" : fairness < 0 ? "away" : "draw";
+  if (abs(fairness) >= TH.fairnessStrong && win !== "draw" && dominantSide !== "draw" && win !== dominantSide) {
+    flags.push("DOMINANCE_NO_RESULT");
+  }
+
+  if (leadMin >= 20 && fragility >= TH.fragStrong) flags.push("FRAGILE_LEAD");
+  if (mismatch >= TH.xMismatch1) flags.push("SCORE_MISMATCH");
+  if (flips >= TH.flipsStrong) flags.push("HIGH_VOLATILITY");
+
+  if (win !== "draw" && Array.isArray(report?.goals) && report.goals.length) {
+    const goals = report.goals.slice().sort((a, b) => a.minute - b.minute);
+    // aproximación: gol decisivo = último gol del ganador
+    let decisive = null;
+    for (const g of goals) if (g.team === win) decisive = g;
+
+    if (decisive && decisive.minute >= TH.lateMin) {
+      if (decisive.label === "mixed" || decisive.label === "against_flow") {
+        flags.push("LATE_DECISIVE_AGAINST_FLOW");
+      }
+    }
+  }
+
+  // Bonus por flags
+  let bonus = 0;
+  if (flags.includes("FRAGILE_LEAD")) bonus += 8;
+  if (flags.includes("HIGH_VOLATILITY")) bonus += 6;
+  if (flags.includes("LATE_DECISIVE_AGAINST_FLOW")) bonus += 10;
+  if (flags.includes("DOMINANCE_NO_RESULT")) bonus += 10;
+
+  const MAI = Math.min(100, Math.max(0, Math.round(100 * MAI01) + bonus));
+
+  let label = "Normal";
+  if (MAI >= 70) label = "Partido roto";
+  else if (MAI >= 50) label = "Resultado engañoso";
+  else if (MAI >= 30) label = "Inestable";
+
+  const reasons = [];
+  if (abs(fairness) >= TH.fairnessStrong) reasons.push(`Dominio ${fairness > 0 ? "local" : "visitante"} significativo (fairness ${r2(fairness)})`);
+  if (leadMin && fragility >= TH.fragStrong) reasons.push(`Ventaja frágil (${Math.round(fragility * 100)}% del tiempo liderando bajo dominio rival)`);
+  if (mismatch >= TH.xMismatch1) reasons.push(`Marcador vs xScore no cuadra (mismatch ${r2(mismatch)})`);
+  if (flips >= TH.flipsStrong) reasons.push(`Alta volatilidad (flipsStrong ${flips})`);
+  if (flags.includes("LATE_DECISIVE_AGAINST_FLOW")) reasons.push(`Gol decisivo tardío fuera de tendencia`);
+
+  const summaryParts = [];
+  if (flags.includes("DOMINANCE_NO_RESULT")) summaryParts.push("dominó pero no ganó");
+  if (flags.includes("FRAGILE_LEAD")) summaryParts.push("ventaja insostenible");
+  if (flags.includes("SCORE_MISMATCH")) summaryParts.push("marcador engañoso");
+  if (flags.includes("HIGH_VOLATILITY")) summaryParts.push("partido caótico");
+  if (flags.includes("LATE_DECISIVE_AGAINST_FLOW")) summaryParts.push("gol tardío antinatural");
+
+  const summary = summaryParts.length ? summaryParts.join(" · ") : "partido dentro de lo esperado";
+
+  return {
+    MAI,
+    label,
+    flags,
+    reasons,
+    summary,
+    components: {
+      fairness: r2(fairness),
+      fairnessN: r2(fairnessN),
+      fragility: r2(fragility),
+      fragilityN: r2(fragilityN),
+      mismatch: r2(mismatch),
+      mismatchN: r2(mismatchN),
+      flips,
+      volatilityN: r2(volatilityN),
+      winner: win,
+      dominantSide
+    }
+  };
+}
+
+module.exports = { buildMatchAnomaly };

package/src/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+
+const { postMatchReport } = require("./postMatchSignals.cjs");
+const { buildMatchAnomaly } = require("./buildMatchAnomaly.cjs");
+const { buildMatchNarrative } = require("./matchNarrative.cjs");
+
+
+async function graphActivity(data = {}) {
+
+  const { id, incidents, graph } = data;
+
+  const matchId = Number(id);
+  if (!matchId) {
+    return { ok: false, error: { code: "missing_id", message: "Match id inválido" } }
+  }
+
+  if (incidents?.ok === false) {
+    return { ok: false, error: { code: "empty_data", message: "missing incidents" } }
+  }
+
+  if (graph?.ok === false) {
+    return { ok: false, error: { code: "empty_data", message: "missing graph" } }
+  }
+
+  const goles = [
+    ...incidents.incidents
+      .filter(i => i.incidentType === "goal")
+      .map(i => ({ minute: i.time, team: "home" })),
+
+    ...incidents.incidents
+      .filter(i => i.incidentType === "goal")
+      .map(i => ({ minute: i.time, team: "away" })),
+  ];
+
+  const input = {
+    graphPoints: graph.graphPoints,
+    goals: goles
+  };
+
+  const report = postMatchReport(input, {
+    maxMinute: 90,
+    W: 7,
+    T: 10,
+    smoothRadius: 2,
+    volT: 12
+  });
+
+
+  const anomaly = buildMatchAnomaly(report);
+  const narrative = buildMatchNarrative({ report, anomaly });
+
+  const MAI = paintMAI(narrative.sentiment.MAI);
+  const Pos = paintPos(narrative.keyFacts.dominanceShare);
+
+  const computed = {
+    mai: MAI,
+    pos: Pos
+  }
+
+  const response = { report, anomaly, narrative, computed };
+
+  return response;
+
+}
+
+
+function paintPos({ home, away }) {
+  const total = home + away;
+
+  if (!total) {
+    return { home: 0, away: 0 };
+  }
+
+  const homePct = Math.round((home / total) * 100);
+  const awayPct = 100 - homePct; // garantiza 100% exacto
+
+  return {
+    home: homePct,
+    away: awayPct
+  };
+}
+
+function paintMAI(MAI) {
+  if (MAI >= 70) return { icon: "🔴", label: "Partido roto" };
+  if (MAI >= 50) return { icon: "🟠", label: "Resultado engañoso" };
+  if (MAI >= 30) return { icon: "🟡", label: "Inestable" };
+  return { icon: "🟢", label: "Normal" };
+}
+
+module.exports = { graphActivity }
+

package/src/matchNarrative.cjs

@@ -0,0 +1,117 @@
+// matchNarrative.cjs
+function pct(x) { return `${Math.round((Number(x) || 0) * 100)}%`; }
+function r2(x) { return Math.round((Number(x) || 0) * 100) / 100; }
+function safe(n, d = 0) { return Number.isFinite(n) ? n : d; }
+
+function winner(finalScore) {
+  const h = finalScore?.home ?? 0;
+  const a = finalScore?.away ?? 0;
+  return h > a ? "home" : a > h ? "away" : "draw";
+}
+function sideName(side) { return side === "home" ? "Local" : side === "away" ? "Visitante" : "Empate"; }
+
+function computeEfficiencyFactor(report) {
+  const eh = safe(report?.efficiency?.home, 0);
+  const ea = safe(report?.efficiency?.away, 0);
+  if (eh <= 0 || ea <= 0) return { factor: 0, side: "none" };
+  if (eh >= ea) return { factor: eh / ea, side: "home" };
+  return { factor: ea / eh, side: "away" };
+}
+
+function pickArchetype({ report, anomaly }, opts = {}) {
+  const fs = report?.finalScore || {};
+  const win = winner(fs);
+  const dominantSide = anomaly?.components?.dominantSide || (report?.fairness > 0 ? "home" : "away");
+  const eff = computeEfficiencyFactor(report);
+  const effExtremeT = opts.effExtremeT ?? 2.5;
+
+  if ((report?.volatility?.flipsStrong || 0) >= (opts.flipsChaos ?? 6)) {
+    return { archetype: "Partido caótico", feeling: "Fuera de guion / impredecible" };
+  }
+
+  if (anomaly?.flags?.includes("DOMINANCE_NO_RESULT")) {
+    if (win !== "draw" && eff.factor >= effExtremeT && eff.side === win) {
+      return { archetype: "Victoria por eficiencia extrema", feeling: "Ganó contra el guion (clínico/azar)" };
+    }
+    return { archetype: "Marcador mentiroso", feeling: "Ganó el que no dominó" };
+  }
+
+  if (anomaly?.flags?.includes("FRAGILE_LEAD") && win !== "draw") {
+    return { archetype: "Ventaja frágil", feeling: "Partido tenso / se sostuvo con pinzas" };
+  }
+
+  if (anomaly?.label === "Resultado engañoso") return { archetype: "Resultado engañoso", feeling: "Lectura peligrosa" };
+  if (anomaly?.label === "Inestable") return { archetype: "Partido inestable", feeling: "Tenso" };
+  return { archetype: "Normal", feeling: "Controlado" };
+}
+
+function buildMatchNarrative({ report, anomaly }, opts = {}) {
+  const fs = report.finalScore;
+  const win = winner(fs);
+  const dominantSide = anomaly?.components?.dominantSide || (report.fairness > 0 ? "home" : "away");
+
+  const domShare = report?.dominanceShare || {};
+  const domHome = safe(domShare.home, 0);
+  const domAway = safe(domShare.away, 0);
+
+  const fairness = safe(report?.fairness, 0);
+  const xh = safe(report?.xScore?.home, 0);
+  const xa = safe(report?.xScore?.away, 0);
+  const mismatch = safe(anomaly?.components?.mismatch, 0);
+
+  const eff = computeEfficiencyFactor(report);
+  const effText = eff.factor > 0 ? `${sideName(eff.side)} fue ~${r2(eff.factor)}× más eficiente` : "Eficiencia no concluyente";
+
+  const gs = report?.gameStateImpact || {};
+  const homeLead = gs.home_leading || { minutes: 0, homePerMin: 0, awayPerMin: 0 };
+  const awayLead = gs.away_leading || { minutes: 0, homePerMin: 0, awayPerMin: 0 };
+
+  const frag = report?.leadFragility || {};
+  const fragHome = frag.homeLeadingButDominatedMinutes || 0;
+  const fragAway = frag.awayLeadingButDominatedMinutes || 0;
+
+  const { archetype, feeling } = pickArchetype({ report, anomaly }, opts);
+
+  const bullets = [];
+  bullets.push(`Dominio: ${sideName(dominantSide)} (${pct(dominantSide === "home" ? domHome : domAway)} de presión, fairness ${r2(fairness)})`);
+  bullets.push(`xScore: ${r2(xh)}–${r2(xa)} (mismatch ${r2(mismatch)})`);
+  bullets.push(effText);
+
+  if (homeLead.minutes) bullets.push(`Cuando Local iba ganando (${homeLead.minutes}m): presión/min Local ${r2(homeLead.homePerMin)} vs Visitante ${r2(homeLead.awayPerMin)}`);
+  if (awayLead.minutes) bullets.push(`Cuando Visitante iba ganando (${awayLead.minutes}m): presión/min Local ${r2(awayLead.homePerMin)} vs Visitante ${r2(awayLead.awayPerMin)}`);
+
+  if (fragHome || fragAway) bullets.push(`Fragilidad: Local lideró dominado ${fragHome}m · Visitante lideró dominado ${fragAway}m`);
+
+  const flips = report?.volatility?.flipsStrong || 0;
+  bullets.push(`Volatilidad: flipsStrong ${flips}`);
+
+  const short =
+    anomaly.label === "Resultado engañoso"
+      ? `Marcador mentiroso: dominó ${sideName(dominantSide)} pero ganó ${sideName(win)}`
+      : `${anomaly.label}: ${anomaly.summary}`;
+
+  const narrative = [
+    `${sideName(win)} gana ${fs.home}-${fs.away}, pero el partido favoreció a ${sideName(dominantSide)}.`,
+    `Se esperaba algo cercano a ${r2(xh)}–${r2(xa)} (xScore).`,
+    `${effText}.`
+  ].join(" ");
+
+  return {
+    sentiment: { label: anomaly.label, feeling, archetype, MAI: anomaly.MAI },
+    keyFacts: {
+      winner: win,
+      dominantSide,
+      finalScore: fs,
+      dominanceShare: { home: domHome, away: domAway },
+      fairness,
+      xScore: { home: xh, away: xa },
+      mismatch,
+      efficiencyFactor: eff
+    },
+    bullets,
+    short,
+    narrative
+  };
+}
+
+module.exports = { buildMatchNarrative };

package/src/postMatchSignals.cjs

@@ -0,0 +1,89 @@
+// postMatchSignals.cjs
+const {
+  resampleGraphPoints,
+  smoothSeries,
+  totalPressureFromSmooth,
+  detectPhases,
+  buildScoreTimeline,
+  gameStateImpact,
+  leadFragilityMinutes,
+  volatilityIndex,
+  buildAlerts,
+  classifyGoal
+} = require("./activitySignals.cjs");
+
+function estimateK(totalPressure, totalGoals) {
+  const g = Math.max(1, totalGoals);
+  return totalPressure / g;
+}
+
+function postMatchReport(data, options = {}) {
+  const maxMinute = options.maxMinute ?? 90;
+  const W = options.W ?? 7;
+  const T = options.T ?? 10;
+  const smoothRadius = options.smoothRadius ?? 2;
+
+  const graphPoints = data?.graphPoints || [];
+  const goals = data?.goals || [];
+
+  const rawSeries = resampleGraphPoints(graphPoints, maxMinute);
+  const smooth = smoothSeries(rawSeries, smoothRadius);
+
+  const totals = totalPressureFromSmooth(smooth);
+
+  const fairness = totals.total > 0 ? (totals.home - totals.away) / totals.total : 0;
+
+  const scoreTimeline = buildScoreTimeline(goals, maxMinute);
+  const finalScore = scoreTimeline[maxMinute];
+  const totalGoals = (finalScore.home || 0) + (finalScore.away || 0);
+
+  const K = options.K ?? estimateK(totals.total, totalGoals);
+  const xScore = { home: totals.home / (K || 1), away: totals.away / (K || 1), K };
+
+  const efficiency = {
+    home: (finalScore.home || 0) / (totals.home + 1e-9),
+    away: (finalScore.away || 0) / (totals.away + 1e-9)
+  };
+
+  const phases = detectPhases(smooth, T);
+  const gs = gameStateImpact(smooth, scoreTimeline);
+  const frag = leadFragilityMinutes(smooth, scoreTimeline, T);
+  const vol = volatilityIndex(smooth, options.volT ?? 12);
+
+  const goalsAnalysis = goals.map(g => classifyGoal(g, smooth, {
+    Wshort: options.Wshort ?? 3,
+    Wlong: options.Wlong ?? 10,
+    swingT: options.swingT ?? 10,
+    shockT: options.shockT ?? 20,
+    levelT: options.levelT ?? 35
+  }));
+
+  const alerts = buildAlerts(smooth, scoreTimeline, {
+    W: options.alertW ?? 10,
+    T,
+    pressureMin: options.pressureMin ?? 80
+  });
+
+  return {
+    finalScore,
+    dominanceShare: totals.total ? { home: totals.home / totals.total, away: totals.away / totals.total } : { home: 0.5, away: 0.5 },
+    fairness,
+    xScore: { home: Number(xScore.home.toFixed(2)), away: Number(xScore.away.toFixed(2)), K: Number(xScore.K.toFixed(2)) },
+    efficiency: { home: Number(efficiency.home.toFixed(6)), away: Number(efficiency.away.toFixed(6)) },
+    leadFragility: frag,
+    gameStateImpact: gs,
+    turningPoints: [], // lo puedes implementar luego (opcional)
+    volatility: vol,
+    phases,
+    goals: goalsAnalysis,
+    alertsLiveStyle: alerts,
+    summary: {
+      totalPressure: { home: totals.home, away: totals.away },
+      dominance: totals.home >= totals.away ? "home" : "away",
+      finalScore
+    },
+    debug: { TUsed: T, WUsed: W, smoothRadius }
+  };
+}
+
+module.exports = { postMatchReport };