evo360-types 1.3.654 → 1.3.659

package/dist/types/evo-csq/index.d.ts

@@ -288,8 +288,17 @@ export interface ICsqClaimAppointmentInformed {
      *  jornada (o lead cancelou/desistiu, ou foi trocado por outro horario). O
      *  codigo nao exige registro na agenda de um claim assim. */
     superseded?: boolean;
+    /** feat-206 F3: quem extraiu o claim. Ausente = o juiz (laudos anteriores a
+     *  F3 e claim so do juiz). `detector` = so o detector de agenda; `both` = os
+     *  dois (mesma data/hora; a evidencia e a uniao). */
+    source?: CsqClaimSource;
+    /** feat-206 F3: `YYYY-MM-DD|HH:mm` do horario que substituiu este (o
+     *  detector viu um horario confirmado depois). */
+    superseded_by?: string;
     evidence: ICsqEvidence[];
 }
+/** feat-206 F3: origem de um claim `appointment_informed`. */
+export type CsqClaimSource = "judge" | "detector" | "both";
 /** "Prometi X ate quando". */
 export interface ICsqClaimPromise {
     type: "promise";
@@ -496,6 +505,71 @@ export interface ICsqTriageDecision {
     mode: CsqTriageMode;
     reasons: CsqTriageReason[];
 }
+/** Evento canonico de agenda extraido pelo detector (independente do juiz).
+ *  `slot_offered` sozinho nao vira claim: oferta nao aceita nao e agendamento
+ *  informado. */
+export type CsqAppointmentEventKind = "slot_offered" | "slot_accepted" | "appointment_confirmed" | "reschedule_requested" | "appointment_cancelled";
+/** Quem produziu o evento na conversa. */
+export type CsqAppointmentEventActor = "attendant" | "lead" | "hubia" | "automation";
+export interface ICsqAppointmentEvent {
+    kind: CsqAppointmentEventKind;
+    /** YYYY-MM-DD absoluto, TZ do tenant. */
+    date?: string;
+    /** HH:mm absoluto, TZ do tenant. */
+    time?: string;
+    professional?: string;
+    patient_name?: string;
+    modality?: string;
+    actor: CsqAppointmentEventActor;
+    /** `message_id`/`ticket_id` do recorte; `ts` sempre do transcript. */
+    evidence: ICsqEvidence[];
+    /** `YYYY-MM-DD|HH:mm` (hora pode faltar: `YYYY-MM-DD|`) do agendamento que
+     *  este evento cancela ou remarca. */
+    supersedes?: string;
+}
+/** `off`: nao roda; `shadow`: roda e registra em `report.detector`, sem mexer
+ *  nos claims; `on`: os claims do detector entram na verificacao. */
+export type CsqDetectorMode = "off" | "shadow" | "on";
+/** Como terminou a extracao por LLM do detector. */
+export type CsqDetectorOutcome = "no_signal" | "ok" | "failed" | "skipped";
+/** Uso do LLM do extrator (so quando houve chamada). */
+export interface ICsqDetectorLlm {
+    provider: string;
+    model: string;
+    /** Doc em `llm-connections`; `null` quando sintetica. */
+    connection_id: string | null;
+    /** `extractor` = `extractor_connection_id`; `judge` = conexao do juiz. */
+    connection_source: "extractor" | "judge";
+    input_tokens: number;
+    /** Parte da entrada servida do cache do provedor (OpenAI: prefixo do system). */
+    cache_read_tokens?: number;
+    output_tokens: number;
+    rounds: number;
+    cost_usd_est: number | null;
+    duration_ms: number;
+}
+/** Divergencia detector x juiz do laudo (registrada, nao escalada — F4). */
+export interface ICsqDetectorReport {
+    mode: CsqDetectorMode;
+    outcome: CsqDetectorOutcome;
+    /** Mensagens com sinal deterministico (data/hora, confirmacao, desfecho). */
+    signals: number;
+    /** Mensagens no recorte enviado ao extrator (sinais + vizinhanca). */
+    excerpt_messages: number;
+    events: number;
+    claims_detector: number;
+    claims_judge: number;
+    only_detector: number;
+    only_judge: number;
+    superseded_by_detector: number;
+    /** Claims do detector no MESMO dia de um claim do juiz, com outra hora: nao
+     *  entram na verificacao (o juiz manda), so contam. */
+    time_mismatch?: number;
+    /** Eventos extraidos (com evidencia ja validada). */
+    event_list?: ICsqAppointmentEvent[];
+    llm?: ICsqDetectorLlm | null;
+    error?: string;
+}
 /** Tamanho de um bloco do prompt do juiz. `tokens_est` e estimativa
  *  deterministica (chars / 3,6), nao contagem do tokenizer. */
 export interface ICsqPromptBlockUsage {
@@ -818,4 +892,7 @@ export interface ICsqLeadReport extends IFireDoc {
     /** feat-206: presente quando o ULTIMO ticket nao passou pelo juiz. A avaliacao
      *  (score, pilares, criterios), `model` e `llm_usage` sao do ultimo juiz. */
     judge_skipped_reasons?: CsqTriageReason[];
+    /** feat-206 F3: detector de agenda (contagens e divergencia com o juiz).
+     *  Ausente quando o detector esta `off` ou o laudo e anterior a F3. */
+    detector?: ICsqDetectorReport;
 }

package/dist/types/evo-csq/index.ts

@@ -501,9 +501,19 @@ export interface ICsqClaimAppointmentInformed {
    *  jornada (o lead cancelou/desistiu, ou foi trocado por outro horario). O
    *  codigo nao exige registro na agenda de um claim assim. */
   superseded?: boolean;
+  /** feat-206 F3: quem extraiu o claim. Ausente = o juiz (laudos anteriores a
+   *  F3 e claim so do juiz). `detector` = so o detector de agenda; `both` = os
+   *  dois (mesma data/hora; a evidencia e a uniao). */
+  source?: CsqClaimSource;
+  /** feat-206 F3: `YYYY-MM-DD|HH:mm` do horario que substituiu este (o
+   *  detector viu um horario confirmado depois). */
+  superseded_by?: string;
   evidence: ICsqEvidence[];
 }
 
+/** feat-206 F3: origem de um claim `appointment_informed`. */
+export type CsqClaimSource = "judge" | "detector" | "both";
+
 /** "Prometi X ate quando". */
 export interface ICsqClaimPromise {
   type: "promise";
@@ -767,6 +777,85 @@ export interface ICsqTriageDecision {
   reasons: CsqTriageReason[];
 }
 
+// ───────── Detector de agenda (feat-206 F3) ─────────
+
+/** Evento canonico de agenda extraido pelo detector (independente do juiz).
+ *  `slot_offered` sozinho nao vira claim: oferta nao aceita nao e agendamento
+ *  informado. */
+export type CsqAppointmentEventKind =
+  | "slot_offered"
+  | "slot_accepted"
+  | "appointment_confirmed"
+  | "reschedule_requested"
+  | "appointment_cancelled";
+
+/** Quem produziu o evento na conversa. */
+export type CsqAppointmentEventActor = "attendant" | "lead" | "hubia" | "automation";
+
+export interface ICsqAppointmentEvent {
+  kind: CsqAppointmentEventKind;
+  /** YYYY-MM-DD absoluto, TZ do tenant. */
+  date?: string;
+  /** HH:mm absoluto, TZ do tenant. */
+  time?: string;
+  professional?: string;
+  patient_name?: string;
+  modality?: string;
+  actor: CsqAppointmentEventActor;
+  /** `message_id`/`ticket_id` do recorte; `ts` sempre do transcript. */
+  evidence: ICsqEvidence[];
+  /** `YYYY-MM-DD|HH:mm` (hora pode faltar: `YYYY-MM-DD|`) do agendamento que
+   *  este evento cancela ou remarca. */
+  supersedes?: string;
+}
+
+/** `off`: nao roda; `shadow`: roda e registra em `report.detector`, sem mexer
+ *  nos claims; `on`: os claims do detector entram na verificacao. */
+export type CsqDetectorMode = "off" | "shadow" | "on";
+
+/** Como terminou a extracao por LLM do detector. */
+export type CsqDetectorOutcome = "no_signal" | "ok" | "failed" | "skipped";
+
+/** Uso do LLM do extrator (so quando houve chamada). */
+export interface ICsqDetectorLlm {
+  provider: string;
+  model: string;
+  /** Doc em `llm-connections`; `null` quando sintetica. */
+  connection_id: string | null;
+  /** `extractor` = `extractor_connection_id`; `judge` = conexao do juiz. */
+  connection_source: "extractor" | "judge";
+  input_tokens: number;
+  /** Parte da entrada servida do cache do provedor (OpenAI: prefixo do system). */
+  cache_read_tokens?: number;
+  output_tokens: number;
+  rounds: number;
+  cost_usd_est: number | null;
+  duration_ms: number;
+}
+
+/** Divergencia detector x juiz do laudo (registrada, nao escalada — F4). */
+export interface ICsqDetectorReport {
+  mode: CsqDetectorMode;
+  outcome: CsqDetectorOutcome;
+  /** Mensagens com sinal deterministico (data/hora, confirmacao, desfecho). */
+  signals: number;
+  /** Mensagens no recorte enviado ao extrator (sinais + vizinhanca). */
+  excerpt_messages: number;
+  events: number;
+  claims_detector: number;
+  claims_judge: number;
+  only_detector: number;
+  only_judge: number;
+  superseded_by_detector: number;
+  /** Claims do detector no MESMO dia de um claim do juiz, com outra hora: nao
+   *  entram na verificacao (o juiz manda), so contam. */
+  time_mismatch?: number;
+  /** Eventos extraidos (com evidencia ja validada). */
+  event_list?: ICsqAppointmentEvent[];
+  llm?: ICsqDetectorLlm | null;
+  error?: string;
+}
+
 /** Tamanho de um bloco do prompt do juiz. `tokens_est` e estimativa
  *  deterministica (chars / 3,6), nao contagem do tokenizer. */
 export interface ICsqPromptBlockUsage {
@@ -1127,4 +1216,7 @@ export interface ICsqLeadReport extends IFireDoc {
   /** feat-206: presente quando o ULTIMO ticket nao passou pelo juiz. A avaliacao
    *  (score, pilares, criterios), `model` e `llm_usage` sao do ultimo juiz. */
   judge_skipped_reasons?: CsqTriageReason[];
+  /** feat-206 F3: detector de agenda (contagens e divergencia com o juiz).
+   *  Ausente quando o detector esta `off` ou o laudo e anterior a F3. */
+  detector?: ICsqDetectorReport;
 }

package/dist/types/evo-modules/activation.d.ts

@@ -0,0 +1,46 @@
+import type { ITenantModuleEntitlement } from "../evo-tenant";
+/**
+ * Normaliza qualquer forma de data que chega às superfícies: `Date`, Firestore
+ * `Timestamp` (`toDate()`), Timestamp serializado (`{_seconds}` / `{seconds}`),
+ * ISO string e epoch em ms. Inválido ⇒ `null` (equivale a "sem data").
+ */
+export declare function moduleDateToMillis(value: unknown): number | null;
+/**
+ * Decide se o entitlement autoriza um uso NOVO do módulo. Função pura e ÚNICA:
+ * backend (`Core.Tenant.isModuleActive`), web-app e Nexus usam esta; o Flutter
+ * espelha e prova pela fixture `fixtures/tenant-modules/is-module-active.parity.json`.
+ *
+ * Ordem das cláusulas (importa):
+ * 1. `override_until` futuro COM `override_by` libera (D6: exceção operacional
+ *    temporária e auditada) — mesmo suspenso/cancelado/vencido;
+ * 2. `enabled !== true` bloqueia;
+ * 3. `suspended`/`cancelled` bloqueiam;
+ * 4. `effective_at` no futuro bloqueia;
+ * 5. `expires_at` no passado (ou agora) bloqueia, para QUALQUER status;
+ * 6. só `active` e `trial` liberam.
+ *
+ * Não tem parâmetro de papel: super admin não ignora entitlement (D6).
+ */
+export declare function isModuleActive(entitlement: ITenantModuleEntitlement | null | undefined, now?: Date): boolean;
+/**
+ * Capability ausente, não-booleana (`"true"`, `1`) ou `false` equivale a `false`.
+ * Não implica módulo ativo: o gate de UI equivalente ao backend é
+ * `isModuleActive(e) && hasModuleCapability(e, cap)`.
+ */
+export declare function hasModuleCapability(entitlement: ITenantModuleEntitlement | null | undefined, capability: string): boolean;
+export interface IModuleContractMismatch {
+    module: string;
+    metric: string;
+    kind: "active_without_allowance" | "allowance_without_module";
+}
+/**
+ * Divergências entre franquias do contrato (`allowances`) e módulos do tenant,
+ * pelas `allowance_metrics` do catálogo. Só informa (a tela de contrato mostra);
+ * nada sincroniza sozinho (Q1).
+ *
+ * - `active_without_allowance`: módulo ativo e nenhuma métrica dele no contrato
+ *   (consumo invisível ao alerta e ao portal);
+ * - `allowance_without_module`: contrato tem franquia de uma métrica do módulo e
+ *   o módulo não está ativo.
+ */
+export declare function moduleContractMismatches(allowances: Record<string, unknown> | null | undefined, modules: Record<string, ITenantModuleEntitlement> | null | undefined, now?: Date): IModuleContractMismatch[];

package/dist/types/evo-modules/activation.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleDateToMillis = moduleDateToMillis;
+exports.isModuleActive = isModuleActive;
+exports.hasModuleCapability = hasModuleCapability;
+exports.moduleContractMismatches = moduleContractMismatches;
+const catalog_1 = require("./catalog");
+/**
+ * Normaliza qualquer forma de data que chega às superfícies: `Date`, Firestore
+ * `Timestamp` (`toDate()`), Timestamp serializado (`{_seconds}` / `{seconds}`),
+ * ISO string e epoch em ms. Inválido ⇒ `null` (equivale a "sem data").
+ */
+function moduleDateToMillis(value) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    if (value instanceof Date) {
+        const t = value.getTime();
+        return isNaN(t) ? null : t;
+    }
+    if (typeof value === "number")
+        return isFinite(value) ? value : null;
+    if (typeof value === "string") {
+        const t = new Date(value).getTime();
+        return isNaN(t) ? null : t;
+    }
+    if (typeof value === "object") {
+        const v = value;
+        if (typeof v.toDate === "function") {
+            try {
+                const d = v.toDate();
+                if (d instanceof Date) {
+                    const t = d.getTime();
+                    return isNaN(t) ? null : t;
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        }
+        const seconds = typeof v._seconds === "number" ? v._seconds : typeof v.seconds === "number" ? v.seconds : null;
+        if (seconds !== null && isFinite(seconds)) {
+            const nanos = typeof v._nanoseconds === "number" ? v._nanoseconds : typeof v.nanoseconds === "number" ? v.nanoseconds : 0;
+            return seconds * 1000 + Math.floor(nanos / 1e6);
+        }
+    }
+    return null;
+}
+/**
+ * Decide se o entitlement autoriza um uso NOVO do módulo. Função pura e ÚNICA:
+ * backend (`Core.Tenant.isModuleActive`), web-app e Nexus usam esta; o Flutter
+ * espelha e prova pela fixture `fixtures/tenant-modules/is-module-active.parity.json`.
+ *
+ * Ordem das cláusulas (importa):
+ * 1. `override_until` futuro COM `override_by` libera (D6: exceção operacional
+ *    temporária e auditada) — mesmo suspenso/cancelado/vencido;
+ * 2. `enabled !== true` bloqueia;
+ * 3. `suspended`/`cancelled` bloqueiam;
+ * 4. `effective_at` no futuro bloqueia;
+ * 5. `expires_at` no passado (ou agora) bloqueia, para QUALQUER status;
+ * 6. só `active` e `trial` liberam.
+ *
+ * Não tem parâmetro de papel: super admin não ignora entitlement (D6).
+ */
+function isModuleActive(entitlement, now = new Date()) {
+    if (!entitlement || typeof entitlement !== "object")
+        return false;
+    const t = now.getTime();
+    const overrideUntil = moduleDateToMillis(entitlement.override_until);
+    if (overrideUntil !== null && overrideUntil > t && !!entitlement.override_by)
+        return true;
+    if (entitlement.enabled !== true)
+        return false;
+    if (entitlement.status === "suspended" || entitlement.status === "cancelled")
+        return false;
+    const effectiveAt = moduleDateToMillis(entitlement.effective_at);
+    if (effectiveAt !== null && effectiveAt > t)
+        return false;
+    const expiresAt = moduleDateToMillis(entitlement.expires_at);
+    if (expiresAt !== null && expiresAt <= t)
+        return false;
+    return entitlement.status === "active" || entitlement.status === "trial";
+}
+/**
+ * Capability ausente, não-booleana (`"true"`, `1`) ou `false` equivale a `false`.
+ * Não implica módulo ativo: o gate de UI equivalente ao backend é
+ * `isModuleActive(e) && hasModuleCapability(e, cap)`.
+ */
+function hasModuleCapability(entitlement, capability) {
+    if (!entitlement || !entitlement.capabilities)
+        return false;
+    return entitlement.capabilities[capability] === true;
+}
+/**
+ * Divergências entre franquias do contrato (`allowances`) e módulos do tenant,
+ * pelas `allowance_metrics` do catálogo. Só informa (a tela de contrato mostra);
+ * nada sincroniza sozinho (Q1).
+ *
+ * - `active_without_allowance`: módulo ativo e nenhuma métrica dele no contrato
+ *   (consumo invisível ao alerta e ao portal);
+ * - `allowance_without_module`: contrato tem franquia de uma métrica do módulo e
+ *   o módulo não está ativo.
+ */
+function moduleContractMismatches(allowances, modules, now = new Date()) {
+    const out = [];
+    const allow = allowances && typeof allowances === "object" ? allowances : {};
+    const mods = modules && typeof modules === "object" ? modules : {};
+    for (const key in catalog_1.PLATFORM_MODULE_CATALOG) {
+        if (!Object.prototype.hasOwnProperty.call(catalog_1.PLATFORM_MODULE_CATALOG, key))
+            continue;
+        const def = catalog_1.PLATFORM_MODULE_CATALOG[key];
+        if (def.allowance_metrics.length === 0)
+            continue;
+        const active = isModuleActive(Object.prototype.hasOwnProperty.call(mods, key) ? mods[key] : null, now);
+        const present = [];
+        for (const m of def.allowance_metrics) {
+            if (Object.prototype.hasOwnProperty.call(allow, m.metric) && allow[m.metric] !== null && allow[m.metric] !== undefined) {
+                present.push(m.metric);
+            }
+        }
+        if (active && present.length === 0) {
+            out.push({ module: key, metric: def.allowance_metrics[0].metric, kind: "active_without_allowance" });
+        }
+        if (!active) {
+            for (const metric of present) {
+                out.push({ module: key, metric, kind: "allowance_without_module" });
+            }
+        }
+    }
+    return out;
+}

package/dist/types/evo-modules/activation.ts

@@ -0,0 +1,150 @@
+import type { ITenantModuleEntitlement } from "../evo-tenant";
+import { PLATFORM_MODULE_CATALOG } from "./catalog";
+
+/**
+ * Normaliza qualquer forma de data que chega às superfícies: `Date`, Firestore
+ * `Timestamp` (`toDate()`), Timestamp serializado (`{_seconds}` / `{seconds}`),
+ * ISO string e epoch em ms. Inválido ⇒ `null` (equivale a "sem data").
+ */
+export function moduleDateToMillis(value: unknown): number | null {
+  if (value === null || value === undefined || value === "") return null;
+  if (value instanceof Date) {
+    const t = value.getTime();
+    return isNaN(t) ? null : t;
+  }
+  if (typeof value === "number") return isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const t = new Date(value).getTime();
+    return isNaN(t) ? null : t;
+  }
+  if (typeof value === "object") {
+    const v = value as {
+      toDate?: unknown;
+      _seconds?: unknown;
+      seconds?: unknown;
+      _nanoseconds?: unknown;
+      nanoseconds?: unknown;
+    };
+    if (typeof v.toDate === "function") {
+      try {
+        const d = (v.toDate as () => unknown)();
+        if (d instanceof Date) {
+          const t = d.getTime();
+          return isNaN(t) ? null : t;
+        }
+      } catch {
+        return null;
+      }
+      return null;
+    }
+    const seconds = typeof v._seconds === "number" ? v._seconds : typeof v.seconds === "number" ? v.seconds : null;
+    if (seconds !== null && isFinite(seconds)) {
+      const nanos =
+        typeof v._nanoseconds === "number" ? v._nanoseconds : typeof v.nanoseconds === "number" ? v.nanoseconds : 0;
+      return seconds * 1000 + Math.floor(nanos / 1e6);
+    }
+  }
+  return null;
+}
+
+/**
+ * Decide se o entitlement autoriza um uso NOVO do módulo. Função pura e ÚNICA:
+ * backend (`Core.Tenant.isModuleActive`), web-app e Nexus usam esta; o Flutter
+ * espelha e prova pela fixture `fixtures/tenant-modules/is-module-active.parity.json`.
+ *
+ * Ordem das cláusulas (importa):
+ * 1. `override_until` futuro COM `override_by` libera (D6: exceção operacional
+ *    temporária e auditada) — mesmo suspenso/cancelado/vencido;
+ * 2. `enabled !== true` bloqueia;
+ * 3. `suspended`/`cancelled` bloqueiam;
+ * 4. `effective_at` no futuro bloqueia;
+ * 5. `expires_at` no passado (ou agora) bloqueia, para QUALQUER status;
+ * 6. só `active` e `trial` liberam.
+ *
+ * Não tem parâmetro de papel: super admin não ignora entitlement (D6).
+ */
+export function isModuleActive(
+  entitlement: ITenantModuleEntitlement | null | undefined,
+  now: Date = new Date(),
+): boolean {
+  if (!entitlement || typeof entitlement !== "object") return false;
+
+  const t = now.getTime();
+
+  const overrideUntil = moduleDateToMillis(entitlement.override_until);
+  if (overrideUntil !== null && overrideUntil > t && !!entitlement.override_by) return true;
+
+  if (entitlement.enabled !== true) return false;
+  if (entitlement.status === "suspended" || entitlement.status === "cancelled") return false;
+
+  const effectiveAt = moduleDateToMillis(entitlement.effective_at);
+  if (effectiveAt !== null && effectiveAt > t) return false;
+
+  const expiresAt = moduleDateToMillis(entitlement.expires_at);
+  if (expiresAt !== null && expiresAt <= t) return false;
+
+  return entitlement.status === "active" || entitlement.status === "trial";
+}
+
+/**
+ * Capability ausente, não-booleana (`"true"`, `1`) ou `false` equivale a `false`.
+ * Não implica módulo ativo: o gate de UI equivalente ao backend é
+ * `isModuleActive(e) && hasModuleCapability(e, cap)`.
+ */
+export function hasModuleCapability(
+  entitlement: ITenantModuleEntitlement | null | undefined,
+  capability: string,
+): boolean {
+  if (!entitlement || !entitlement.capabilities) return false;
+  return entitlement.capabilities[capability] === true;
+}
+
+export interface IModuleContractMismatch {
+  module: string;
+  metric: string;
+  kind: "active_without_allowance" | "allowance_without_module";
+}
+
+/**
+ * Divergências entre franquias do contrato (`allowances`) e módulos do tenant,
+ * pelas `allowance_metrics` do catálogo. Só informa (a tela de contrato mostra);
+ * nada sincroniza sozinho (Q1).
+ *
+ * - `active_without_allowance`: módulo ativo e nenhuma métrica dele no contrato
+ *   (consumo invisível ao alerta e ao portal);
+ * - `allowance_without_module`: contrato tem franquia de uma métrica do módulo e
+ *   o módulo não está ativo.
+ */
+export function moduleContractMismatches(
+  allowances: Record<string, unknown> | null | undefined,
+  modules: Record<string, ITenantModuleEntitlement> | null | undefined,
+  now: Date = new Date(),
+): IModuleContractMismatch[] {
+  const out: IModuleContractMismatch[] = [];
+  const allow = allowances && typeof allowances === "object" ? allowances : {};
+  const mods = modules && typeof modules === "object" ? modules : {};
+
+  for (const key in PLATFORM_MODULE_CATALOG) {
+    if (!Object.prototype.hasOwnProperty.call(PLATFORM_MODULE_CATALOG, key)) continue;
+    const def = PLATFORM_MODULE_CATALOG[key];
+    if (def.allowance_metrics.length === 0) continue;
+
+    const active = isModuleActive(Object.prototype.hasOwnProperty.call(mods, key) ? mods[key] : null, now);
+    const present: string[] = [];
+    for (const m of def.allowance_metrics) {
+      if (Object.prototype.hasOwnProperty.call(allow, m.metric) && allow[m.metric] !== null && allow[m.metric] !== undefined) {
+        present.push(m.metric);
+      }
+    }
+
+    if (active && present.length === 0) {
+      out.push({ module: key, metric: def.allowance_metrics[0].metric, kind: "active_without_allowance" });
+    }
+    if (!active) {
+      for (const metric of present) {
+        out.push({ module: key, metric, kind: "allowance_without_module" });
+      }
+    }
+  }
+  return out;
+}

package/dist/types/evo-modules/catalog.d.ts

@@ -0,0 +1,28 @@
+import type { IPlatformModuleDefinition } from "./index";
+/**
+ * Versão do catálogo, gravada em `IModuleProvisioningRun.types_version`.
+ * Mudou capability, passo, grupo ou métrica de algum módulo ⇒ incrementar: o
+ * run antigo precisa dizer com que catálogo foi planejado.
+ */
+export declare const PLATFORM_MODULE_CATALOG_VERSION = "2026-10-06.1";
+export declare const PLATFORM_MODULE_TELEMEDICINE = "telemedicine";
+export declare const PLATFORM_MODULE_CSQ = "csq";
+/**
+ * Catálogo de módulos da plataforma (feat-263). É código, não Firestore: carrega
+ * comportamento (passos, grupos, métricas) e precisa de versionamento e tipos.
+ *
+ * Módulo novo = uma entrada aqui + publish. O estado por tenant continua em
+ * `tenants/{t}.modules[key]`.
+ */
+export declare const PLATFORM_MODULE_CATALOG: Readonly<Record<string, IPlatformModuleDefinition>>;
+export declare function getModuleDefinition(key: string | null | undefined): IPlatformModuleDefinition | null;
+/** Definições em ordem estável (ordem de declaração). */
+export declare function listModuleDefinitions(): IPlatformModuleDefinition[];
+/** Chaves do catálogo em ordem de declaração. */
+export declare function listModuleKeys(): string[];
+/** Capabilities default do módulo (mapa novo a cada chamada). */
+export declare function buildModuleDefaultCapabilities(definition: IPlatformModuleDefinition): Record<string, boolean | number | string>;
+/** Módulos que tenant novo recebe habilitados. */
+export declare function listDefaultModulesForNewTenants(): IPlatformModuleDefinition[];
+/** União, sem repetição e em ordem, dos grupos RBAC dos módulos default de tenant novo. */
+export declare function listDefaultTenantRbacGroups(): string[];