evo360-types 1.3.367 → 1.3.369

package/dist/apps/evo-hub-ia/v1/zod-schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zAiBindingSchema = exports.zHubiaConversationModeSchema = exports.zHubiaConversationMessageSchema = exports.zHubiaV1ChannelConfigSchema = exports.zHubiaAttendanceModeSchema = void 0;
+exports.zAiBindingSchema = exports.zHubiaRuleSchema = exports.zHubiaRulesModeSchema = exports.zHubiaRuleActionSchema = exports.zHubiaRuleScopeSchema = exports.zHubiaConditionGroupSchema = exports.zHubiaConditionSchema = exports.zHubiaConditionOpSchema = exports.zHubiaRuleAppliesToSchema = exports.zHubiaRuleOutcomeSchema = exports.zHubiaRuleTriggerSchema = exports.zHubiaRulePhaseSchema = exports.zHubiaConversationModeSchema = exports.zHubiaConversationMessageSchema = exports.zHubiaV1ChannelConfigSchema = exports.zHubiaAttendanceModeSchema = void 0;
 const zod_1 = require("zod");
 const zod_schemas_1 = require("../../shared/zod-schemas");
 // ───────── Attendance Mode (how AI operates on this channel) ─────────
@@ -81,6 +81,85 @@ exports.zHubiaConversationMessageSchema = zod_1.z.object({
 }).passthrough();
 // ───────── Conversation Mode ─────────
 exports.zHubiaConversationModeSchema = zod_1.z.enum(["ai_only", "hybrid_assist", "human_only", "blocked"]);
+// ───────── evo-hubia-rules (deterministic rule layer) ─────────
+//
+// Camada de regras determinísticas avaliada pelo motor `evo-hubia-rules`
+// (ver cloud-functions/docs/evo-hubia-rules/). Roda ANTES do LLM (fase
+// `pre_llm`, único escopo de implementação atual). O campo `phase` já
+// reserva espaço arquitetural para um hook `post_llm` futuro.
+//
+// As regras moram em `binding.rules[]` — o binding É o cruzamento canal⨯
+// departamento, então o escopo de departamento é implícito.
+/** Fase de avaliação. Tipos TS em src/types/evo-hub-ia/v1/. */
+exports.zHubiaRulePhaseSchema = zod_1.z.enum(["pre_llm", "post_llm"]);
+exports.zHubiaRuleTriggerSchema = zod_1.z.enum(["inbound_message", "llm_completed"]);
+exports.zHubiaRuleOutcomeSchema = zod_1.z.enum(["stop", "to_llm", "to_llm_with_context"]);
+exports.zHubiaRuleAppliesToSchema = zod_1.z.enum(["real_message", "kickoff", "any"]);
+exports.zHubiaConditionOpSchema = zod_1.z.enum([
+    "exists", "not_exists",
+    "is_empty", "is_not_empty",
+    "eq", "neq",
+    "in", "not_in",
+    "contains", "not_contains",
+    "matches",
+    "gt", "gte", "lt", "lte",
+]);
+/** Uma condição: avalia `op(fact, value)` contra o facts provider do runtime.
+ *  `value` é ausente para `exists`/`not_exists`. */
+exports.zHubiaConditionSchema = zod_1.z.object({
+    /** Dot-path no namespace de facts (ex: "lead.tag_names", "contact.has_lead"). */
+    fact: zod_1.z.string().min(1),
+    op: exports.zHubiaConditionOpSchema,
+    value: zod_1.z.unknown().optional(),
+});
+/** Grupo de condições. Nível 2: um nível de AND/OR, sem aninhamento profundo
+ *  (Nível 3 fica para depois). Pelo menos uma das listas precisa ter ≥1 condição. */
+exports.zHubiaConditionGroupSchema = zod_1.z.object({
+    all: zod_1.z.array(exports.zHubiaConditionSchema).optional(),
+    any: zod_1.z.array(exports.zHubiaConditionSchema).optional(),
+}).refine((v) => (!!v.all && v.all.length > 0) || (!!v.any && v.any.length > 0), { message: "ConditionGroup precisa ter ao menos uma condição em `all` ou `any`." });
+/** Refinamento opcional do escopo. Departamento é implícito (regra mora no
+ *  binding do departamento). */
+exports.zHubiaRuleScopeSchema = zod_1.z.object({
+    applies_to: exports.zHubiaRuleAppliesToSchema.optional(),
+    provider: zod_1.z.enum(["chatbee", "hub-waba"]).optional(),
+}).partial();
+/** Uma ação a executar via ToolRegistry. `input` aceita templating
+ *  `{{fact.path}}` resolvido em runtime pelo facts provider. */
+exports.zHubiaRuleActionSchema = zod_1.z.object({
+    /** Nome de uma tool `category: 'action'` do evo-hubia-tools
+     *  (transfer_to_department, close_attendance, handoff_to_human, update_lead_tags, …). */
+    tool: zod_1.z.string().min(1),
+    input: zod_1.z.record(zod_1.z.unknown()).default({}),
+});
+/** Master switch do binding. `dry_run` força TODAS as regras do binding a
+ *  modo seco (kill switch). Default runtime quando ausente: `live`. */
+exports.zHubiaRulesModeSchema = zod_1.z.enum(["live", "dry_run"]);
+/** Uma regra completa. Mora em `binding.rules[]`. Avaliada pelo motor
+ *  `evo-hubia-rules`. Reusa ToolRegistry para executar actions, herdando
+ *  as policies já existentes (mode, requiresLinkedLead, etc.). */
+exports.zHubiaRuleSchema = zod_1.z.object({
+    /** Identificador estável (auditoria, idempotência). */
+    id: zod_1.z.string().min(1),
+    /** Nome legível ("Paciente existente → Clínica"). */
+    name: zod_1.z.string().min(1),
+    active: zod_1.z.boolean().default(true),
+    /** Menor avalia primeiro (first-match). */
+    priority: zod_1.z.number().int().default(100),
+    phase: exports.zHubiaRulePhaseSchema.default("pre_llm"),
+    when: exports.zHubiaRuleTriggerSchema.default("inbound_message"),
+    scope: exports.zHubiaRuleScopeSchema.optional(),
+    conditions: exports.zHubiaConditionGroupSchema,
+    actions: zod_1.z.array(exports.zHubiaRuleActionSchema).min(1),
+    outcome: exports.zHubiaRuleOutcomeSchema,
+    /** Shadow mode por regra (característica permanente, não só de rollout):
+     *  avalia + grava trace, mas NÃO executa as actions. Permite canário de
+     *  regras novas convivendo com regras live no mesmo binding.
+     *  Efetivo: `binding.rules_mode === 'dry_run' || rule.dry_run === true`. */
+    dry_run: zod_1.z.boolean().default(false),
+    /** Aborta sequência de ações no primeiro erro. */
+    stop_actions_on_error: zod_1.z.boolean().default(true),
+}).passthrough();
 // ───────── AI Binding (department → AI agent routing) ─────────
 const zHubiaCapabilitiesSchema = zod_1.z.object({
     can_schedule: zod_1.z.boolean().default(false),
@@ -112,4 +191,12 @@ exports.zAiBindingSchema = zod_schemas_1.zFireDocSchema.extend({
     /** Prompts específicos do fluxo do departamento (texto inline).
      *  Empilhados após identity/safety/channel_custom do canal. */
     prompt_overrides: zHubiaPromptOverridesSchema.optional(),
+    // ───── evo-hubia-rules (deterministic rule layer) ─────
+    /** Camada de regras determinísticas avaliada antes do LLM (e, no futuro,
+     *  também depois). Ausente/vazio = camada off, comportamento atual (só LLM). */
+    rules: zod_1.z.array(exports.zHubiaRuleSchema).optional(),
+    /** Master switch do binding para a camada de regras.
+     *  `dry_run` força todas as regras deste binding a modo seco (sem executar
+     *  actions; apenas avalia e grava trace). Default runtime quando ausente: `live`. */
+    rules_mode: exports.zHubiaRulesModeSchema.optional(),
 }).passthrough();

package/dist/apps/evo-hub-ia/v1/zod-schemas.ts

@@ -95,6 +95,104 @@ export type IHubiaConversationMessage = z.infer<typeof zHubiaConversationMessage
 export const zHubiaConversationModeSchema = z.enum(["ai_only", "hybrid_assist", "human_only", "blocked"]);
 export type IHubiaConversationMode = z.infer<typeof zHubiaConversationModeSchema>;
 
+// ───────── evo-hubia-rules (deterministic rule layer) ─────────
+//
+// Camada de regras determinísticas avaliada pelo motor `evo-hubia-rules`
+// (ver cloud-functions/docs/evo-hubia-rules/). Roda ANTES do LLM (fase
+// `pre_llm`, único escopo de implementação atual). O campo `phase` já
+// reserva espaço arquitetural para um hook `post_llm` futuro.
+//
+// As regras moram em `binding.rules[]` — o binding É o cruzamento canal⨯
+// departamento, então o escopo de departamento é implícito.
+
+/** Fase de avaliação. Tipos TS em src/types/evo-hub-ia/v1/. */
+export const zHubiaRulePhaseSchema = z.enum(["pre_llm", "post_llm"]);
+
+export const zHubiaRuleTriggerSchema = z.enum(["inbound_message", "llm_completed"]);
+
+export const zHubiaRuleOutcomeSchema = z.enum(["stop", "to_llm", "to_llm_with_context"]);
+
+export const zHubiaRuleAppliesToSchema = z.enum(["real_message", "kickoff", "any"]);
+
+export const zHubiaConditionOpSchema = z.enum([
+  "exists", "not_exists",
+  "is_empty", "is_not_empty",
+  "eq", "neq",
+  "in", "not_in",
+  "contains", "not_contains",
+  "matches",
+  "gt", "gte", "lt", "lte",
+]);
+
+/** Uma condição: avalia `op(fact, value)` contra o facts provider do runtime.
+ *  `value` é ausente para `exists`/`not_exists`. */
+export const zHubiaConditionSchema = z.object({
+  /** Dot-path no namespace de facts (ex: "lead.tag_names", "contact.has_lead"). */
+  fact: z.string().min(1),
+  op: zHubiaConditionOpSchema,
+  value: z.unknown().optional(),
+});
+
+/** Grupo de condições. Nível 2: um nível de AND/OR, sem aninhamento profundo
+ *  (Nível 3 fica para depois). Pelo menos uma das listas precisa ter ≥1 condição. */
+export const zHubiaConditionGroupSchema = z.object({
+  all: z.array(zHubiaConditionSchema).optional(),
+  any: z.array(zHubiaConditionSchema).optional(),
+}).refine(
+  (v) => (!!v.all && v.all.length > 0) || (!!v.any && v.any.length > 0),
+  { message: "ConditionGroup precisa ter ao menos uma condição em `all` ou `any`." },
+);
+
+/** Refinamento opcional do escopo. Departamento é implícito (regra mora no
+ *  binding do departamento). */
+export const zHubiaRuleScopeSchema = z.object({
+  applies_to: zHubiaRuleAppliesToSchema.optional(),
+  provider: z.enum(["chatbee", "hub-waba"]).optional(),
+}).partial();
+
+/** Uma ação a executar via ToolRegistry. `input` aceita templating
+ *  `{{fact.path}}` resolvido em runtime pelo facts provider. */
+export const zHubiaRuleActionSchema = z.object({
+  /** Nome de uma tool `category: 'action'` do evo-hubia-tools
+   *  (transfer_to_department, close_attendance, handoff_to_human, update_lead_tags, …). */
+  tool: z.string().min(1),
+  input: z.record(z.unknown()).default({}),
+});
+
+/** Master switch do binding. `dry_run` força TODAS as regras do binding a
+ *  modo seco (kill switch). Default runtime quando ausente: `live`. */
+export const zHubiaRulesModeSchema = z.enum(["live", "dry_run"]);
+
+/** Uma regra completa. Mora em `binding.rules[]`. Avaliada pelo motor
+ *  `evo-hubia-rules`. Reusa ToolRegistry para executar actions, herdando
+ *  as policies já existentes (mode, requiresLinkedLead, etc.). */
+export const zHubiaRuleSchema = z.object({
+  /** Identificador estável (auditoria, idempotência). */
+  id: z.string().min(1),
+  /** Nome legível ("Paciente existente → Clínica"). */
+  name: z.string().min(1),
+  active: z.boolean().default(true),
+  /** Menor avalia primeiro (first-match). */
+  priority: z.number().int().default(100),
+
+  phase: zHubiaRulePhaseSchema.default("pre_llm"),
+  when: zHubiaRuleTriggerSchema.default("inbound_message"),
+
+  scope: zHubiaRuleScopeSchema.optional(),
+  conditions: zHubiaConditionGroupSchema,
+  actions: z.array(zHubiaRuleActionSchema).min(1),
+  outcome: zHubiaRuleOutcomeSchema,
+
+  /** Shadow mode por regra (característica permanente, não só de rollout):
+   *  avalia + grava trace, mas NÃO executa as actions. Permite canário de
+   *  regras novas convivendo com regras live no mesmo binding.
+   *  Efetivo: `binding.rules_mode === 'dry_run' || rule.dry_run === true`. */
+  dry_run: z.boolean().default(false),
+
+  /** Aborta sequência de ações no primeiro erro. */
+  stop_actions_on_error: z.boolean().default(true),
+}).passthrough();
+
 // ───────── AI Binding (department → AI agent routing) ─────────
 
 const zHubiaCapabilitiesSchema = z.object({
@@ -129,6 +227,15 @@ export const zAiBindingSchema = zFireDocSchema.extend({
   /** Prompts específicos do fluxo do departamento (texto inline).
    *  Empilhados após identity/safety/channel_custom do canal. */
   prompt_overrides: zHubiaPromptOverridesSchema.optional(),
+
+  // ───── evo-hubia-rules (deterministic rule layer) ─────
+  /** Camada de regras determinísticas avaliada antes do LLM (e, no futuro,
+   *  também depois). Ausente/vazio = camada off, comportamento atual (só LLM). */
+  rules: z.array(zHubiaRuleSchema).optional(),
+  /** Master switch do binding para a camada de regras.
+   *  `dry_run` força todas as regras deste binding a modo seco (sem executar
+   *  actions; apenas avalia e grava trace). Default runtime quando ausente: `live`. */
+  rules_mode: zHubiaRulesModeSchema.optional(),
 }).passthrough();
 
 export type IAiBinding = z.infer<typeof zAiBindingSchema>;

package/dist/types/evo-hub-ia/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./channel";
+export * from "./v1";
 export declare const EvoHubiaPermissions: {
     readonly Read: "evo_hubia_read";
 };

package/dist/types/evo-hub-ia/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvoHubiaMcpPermissions = exports.EvoHubiaPermissions = void 0;
 __exportStar(require("./channel"), exports);
+__exportStar(require("./v1"), exports);
 // Permissões para o evo-hubia
 exports.EvoHubiaPermissions = {
     Read: "evo_hubia_read",

package/dist/types/evo-hub-ia/index.ts

@@ -1,4 +1,5 @@
 export * from "./channel";
+export * from "./v1";
 
 // Permissões para o evo-hubia
 export const EvoHubiaPermissions = {

package/dist/types/evo-hub-ia/v1/index.d.ts

@@ -0,0 +1,81 @@
+/** Fase de avaliação. `pre_llm` roda antes do orchestrator;
+ *  `post_llm` está reservado (não implementado nesta entrega). */
+export type IHubiaRulePhase = "pre_llm" | "post_llm";
+/** Gatilho que dispara a avaliação. */
+export type IHubiaRuleTrigger = "inbound_message" | "llm_completed";
+/** Desfecho do turno após a regra disparar:
+ *  - `stop`                — finaliza turno sem chamar o LLM.
+ *  - `to_llm`              — segue para o orchestrator normalmente.
+ *  - `to_llm_with_context` — segue para o orchestrator com trace das ações
+ *                            injetado como bloco de sistema.
+ *  Quando o LLM está desligado no binding (default_mode `human_only`/`blocked`),
+ *  `to_llm`/`to_llm_with_context` degradam para "cai pro humano". */
+export type IHubiaRuleOutcome = "stop" | "to_llm" | "to_llm_with_context";
+/** Tipo de batch ao qual a regra se aplica. `real_message` (default) ignora
+ *  a mensagem de kickoff do sistema — proteção contra loop de transferência. */
+export type IHubiaRuleAppliesTo = "real_message" | "kickoff" | "any";
+/** Operadores suportados pelas condições. */
+export type IHubiaConditionOp = "exists" | "not_exists" | "is_empty" | "is_not_empty" | "eq" | "neq" | "in" | "not_in" | "contains" | "not_contains" | "matches" | "gt" | "gte" | "lt" | "lte";
+/** Master switch do binding. `dry_run` força TODAS as regras do binding a
+ *  modo seco (kill switch). Default runtime quando ausente: `live`. */
+export type IHubiaRulesMode = "live" | "dry_run";
+/** Uma condição: avalia `op(fact, value)` contra o facts provider do runtime.
+ *  `value` é ausente para `exists`/`not_exists`. */
+export interface IHubiaCondition {
+    /** Dot-path no namespace de facts (ex: "lead.tag_names", "contact.has_lead"). */
+    fact: string;
+    op: IHubiaConditionOp;
+    value?: unknown;
+}
+/** Grupo de condições. Nível 2: um nível de AND/OR, sem aninhamento profundo.
+ *  Pelo menos uma das listas precisa ter ≥1 condição (validado em runtime
+ *  pelo refine do schema zod). */
+export interface IHubiaConditionGroup {
+    all?: IHubiaCondition[];
+    any?: IHubiaCondition[];
+}
+/** Refinamento opcional do escopo. Departamento é implícito (regra mora no
+ *  binding do departamento). */
+export interface IHubiaRuleScope {
+    applies_to?: IHubiaRuleAppliesTo;
+    provider?: "chatbee" | "hub-waba";
+}
+/** Uma ação a executar via ToolRegistry. `input` aceita templating
+ *  `{{fact.path}}` resolvido em runtime pelo facts provider. */
+export interface IHubiaRuleAction {
+    /** Nome de uma tool `category: 'action'` do evo-hubia-tools
+     *  (transfer_to_department, close_attendance, handoff_to_human, update_lead_tags, …). */
+    tool: string;
+    input?: Record<string, unknown>;
+}
+/** Uma regra completa. Mora em `binding.rules[]`. Avaliada pelo motor
+ *  `evo-hubia-rules`. Reusa ToolRegistry para executar actions, herdando
+ *  as policies já existentes (mode, requiresLinkedLead, etc.). */
+export interface IHubiaRule {
+    /** Identificador estável (auditoria, idempotência). */
+    id: string;
+    /** Nome legível ("Paciente existente → Clínica"). */
+    name: string;
+    /** Default: true. */
+    active?: boolean;
+    /** Menor avalia primeiro (first-match). Default: 100. */
+    priority?: number;
+    /** Default: "pre_llm". */
+    phase?: IHubiaRulePhase;
+    /** Default: "inbound_message" (compatível com `phase: pre_llm`). */
+    when?: IHubiaRuleTrigger;
+    scope?: IHubiaRuleScope;
+    conditions: IHubiaConditionGroup;
+    actions: IHubiaRuleAction[];
+    outcome: IHubiaRuleOutcome;
+    /** Shadow mode por regra (característica permanente, não só de rollout):
+     *  avalia + grava trace, mas NÃO executa as actions. Permite canário de
+     *  regras novas convivendo com regras live no mesmo binding.
+     *  Efetivo: `binding.rules_mode === 'dry_run' || rule.dry_run === true`.
+     *  Default: false. */
+    dry_run?: boolean;
+    /** Aborta sequência de ações no primeiro erro. Default: true. */
+    stop_actions_on_error?: boolean;
+    /** Passthrough no schema zod — campos custom são preservados. */
+    [key: string]: unknown;
+}

package/dist/types/evo-hub-ia/v1/index.js

@@ -0,0 +1,8 @@
+"use strict";
+// Tipos da camada evo-hubia-rules (motor determinístico pré-LLM).
+// Schemas zod correspondentes ficam em src/apps/evo-hub-ia/v1/zod-schemas.ts;
+// estes tipos são escritos à mão e mantidos em paralelo (convenção do projeto:
+// `apps/` = zod, `types/` = interfaces TS).
+//
+// Ver docs em cloud-functions/docs/evo-hubia-rules/.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/evo-hub-ia/v1/index.ts

@@ -0,0 +1,124 @@
+// Tipos da camada evo-hubia-rules (motor determinístico pré-LLM).
+// Schemas zod correspondentes ficam em src/apps/evo-hub-ia/v1/zod-schemas.ts;
+// estes tipos são escritos à mão e mantidos em paralelo (convenção do projeto:
+// `apps/` = zod, `types/` = interfaces TS).
+//
+// Ver docs em cloud-functions/docs/evo-hubia-rules/.
+
+// ── Enums / Literals ──
+
+/** Fase de avaliação. `pre_llm` roda antes do orchestrator;
+ *  `post_llm` está reservado (não implementado nesta entrega). */
+export type IHubiaRulePhase = "pre_llm" | "post_llm";
+
+/** Gatilho que dispara a avaliação. */
+export type IHubiaRuleTrigger = "inbound_message" | "llm_completed";
+
+/** Desfecho do turno após a regra disparar:
+ *  - `stop`                — finaliza turno sem chamar o LLM.
+ *  - `to_llm`              — segue para o orchestrator normalmente.
+ *  - `to_llm_with_context` — segue para o orchestrator com trace das ações
+ *                            injetado como bloco de sistema.
+ *  Quando o LLM está desligado no binding (default_mode `human_only`/`blocked`),
+ *  `to_llm`/`to_llm_with_context` degradam para "cai pro humano". */
+export type IHubiaRuleOutcome = "stop" | "to_llm" | "to_llm_with_context";
+
+/** Tipo de batch ao qual a regra se aplica. `real_message` (default) ignora
+ *  a mensagem de kickoff do sistema — proteção contra loop de transferência. */
+export type IHubiaRuleAppliesTo = "real_message" | "kickoff" | "any";
+
+/** Operadores suportados pelas condições. */
+export type IHubiaConditionOp =
+  | "exists"
+  | "not_exists"
+  | "is_empty"
+  | "is_not_empty"
+  | "eq"
+  | "neq"
+  | "in"
+  | "not_in"
+  | "contains"
+  | "not_contains"
+  | "matches"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte";
+
+/** Master switch do binding. `dry_run` força TODAS as regras do binding a
+ *  modo seco (kill switch). Default runtime quando ausente: `live`. */
+export type IHubiaRulesMode = "live" | "dry_run";
+
+// ── Sub-interfaces ──
+
+/** Uma condição: avalia `op(fact, value)` contra o facts provider do runtime.
+ *  `value` é ausente para `exists`/`not_exists`. */
+export interface IHubiaCondition {
+  /** Dot-path no namespace de facts (ex: "lead.tag_names", "contact.has_lead"). */
+  fact: string;
+  op: IHubiaConditionOp;
+  value?: unknown;
+}
+
+/** Grupo de condições. Nível 2: um nível de AND/OR, sem aninhamento profundo.
+ *  Pelo menos uma das listas precisa ter ≥1 condição (validado em runtime
+ *  pelo refine do schema zod). */
+export interface IHubiaConditionGroup {
+  all?: IHubiaCondition[];
+  any?: IHubiaCondition[];
+}
+
+/** Refinamento opcional do escopo. Departamento é implícito (regra mora no
+ *  binding do departamento). */
+export interface IHubiaRuleScope {
+  applies_to?: IHubiaRuleAppliesTo;
+  provider?: "chatbee" | "hub-waba";
+}
+
+/** Uma ação a executar via ToolRegistry. `input` aceita templating
+ *  `{{fact.path}}` resolvido em runtime pelo facts provider. */
+export interface IHubiaRuleAction {
+  /** Nome de uma tool `category: 'action'` do evo-hubia-tools
+   *  (transfer_to_department, close_attendance, handoff_to_human, update_lead_tags, …). */
+  tool: string;
+  input?: Record<string, unknown>;
+}
+
+// ── Main ──
+
+/** Uma regra completa. Mora em `binding.rules[]`. Avaliada pelo motor
+ *  `evo-hubia-rules`. Reusa ToolRegistry para executar actions, herdando
+ *  as policies já existentes (mode, requiresLinkedLead, etc.). */
+export interface IHubiaRule {
+  /** Identificador estável (auditoria, idempotência). */
+  id: string;
+  /** Nome legível ("Paciente existente → Clínica"). */
+  name: string;
+  /** Default: true. */
+  active?: boolean;
+  /** Menor avalia primeiro (first-match). Default: 100. */
+  priority?: number;
+
+  /** Default: "pre_llm". */
+  phase?: IHubiaRulePhase;
+  /** Default: "inbound_message" (compatível com `phase: pre_llm`). */
+  when?: IHubiaRuleTrigger;
+
+  scope?: IHubiaRuleScope;
+  conditions: IHubiaConditionGroup;
+  actions: IHubiaRuleAction[];
+  outcome: IHubiaRuleOutcome;
+
+  /** Shadow mode por regra (característica permanente, não só de rollout):
+   *  avalia + grava trace, mas NÃO executa as actions. Permite canário de
+   *  regras novas convivendo com regras live no mesmo binding.
+   *  Efetivo: `binding.rules_mode === 'dry_run' || rule.dry_run === true`.
+   *  Default: false. */
+  dry_run?: boolean;
+
+  /** Aborta sequência de ações no primeiro erro. Default: true. */
+  stop_actions_on_error?: boolean;
+
+  /** Passthrough no schema zod — campos custom são preservados. */
+  [key: string]: unknown;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evo360-types",
-  "version": "1.3.367",
+  "version": "1.3.369",
   "description": "HREVO360 Shared Types",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",