Detalle de Acción + Workflow FARO Connect

{
  "action": {
    "action_id": "23000000-0000-0000-0000-000000000001",
    "action_code": "ACT-COM-001",
    "title": "Revisar política de descuentos",
    "description": "Analizar descuentos aplicados por vendedor, producto, cliente y sucursal.",
    "status": "in_progress",
    "priority": "critical",
    "action_type": "corrective",
    "due_date": "2026-06-06",
    "is_overdue": false,
    "closure_criteria": "Nueva política de descuentos aprobada por dirección y comunicada al equipo comercial.",
    "expected_impact": "Mejora de margen, disciplina comercial y rentabilidad.",
    "expected_score_recovery_min": 3,
    "expected_score_recovery_max": 8,
    "created_at": "2026-05-30T09:03:00-03:00",
    "updated_at": "2026-05-30T11:20:00-03:00"
  },
  "responsible": {
    "user_id": "12000000-0000-0000-0000-000000000002",
    "full_name": "María Fernández",
    "email": "maria@empresa-demo-cuyo.com",
    "role": "commercial_manager"
  },
  "approver": {
    "user_id": "12000000-0000-0000-0000-000000000001",
    "full_name": "Tomás Pombo",
    "email": "direccion@empresa-demo-cuyo.com",
    "role": "general_manager"
  },
  "tension": {
    "tension_id": "22000000-0000-0000-0000-000000000001",
    "tension_code": "TNS-001",
    "title": "Crecimiento no rentable",
    "severity": "critical",
    "priority_score": 92,
    "score_impact": -8.5,
    "business_question": "¿Estamos vendiendo más pero ganando menos?",
    "executive_diagnosis": "La empresa crece en volumen, pero sacrifica rentabilidad."
  },
  "evidence_requirements": [
    {
      "evidence_code": "EVD-007",
      "name": "Cambio de política",
      "description": "Documento, registro o aprobación que acredita un cambio de política.",
      "evidence_type": "document",
      "trust_level": "critical",
      "requires_review": true,
      "can_close_action": true,
      "status": "missing",
      "submitted_count": 0,
      "approved_count": 0
    },
    {
      "evidence_code": "EVD-012",
      "name": "Validación de dirección",
      "description": "Validación formal de dirección registrada en sistema.",
      "evidence_type": "approval",
      "trust_level": "critical",
      "requires_review": false,
      "can_close_action": true,
      "status": "missing",
      "submitted_count": 0,
      "approved_count": 0
    }
  ],
  "submitted_evidence": [],
  "workflow": {
    "can_start": false,
    "can_upload_evidence": true,
    "can_submit_review": false,
    "can_approve": false,
    "can_reject": false,
    "can_close": false,
    "can_block": true,
    "can_escalate": true,
    "can_request_extension": true,
    "blocking_reasons": [
      "Falta EVD-007 · Cambio de política",
      "Falta EVD-012 · Validación de dirección"
    ]
  },
  "timeline": [
    {
      "event_id": "90000000-0000-0000-0000-000000000001",
      "event_type": "action_created",
      "title": "Acción creada por motor FARO",
      "description": "La acción fue creada como recomendación de TNS-001.",
      "actor": { "full_name": "Sistema FARO" },
      "created_at": "2026-05-30T09:03:00-03:00"
    },
    {
      "event_id": "90000000-0000-0000-0000-000000000002",
      "event_type": "action_started",
      "title": "Acción iniciada",
      "description": "El responsable tomó la acción.",
      "actor": { "full_name": "María Fernández" },
      "created_at": "2026-05-30T11:20:00-03:00"
    }
  ]
}

CREATE OR REPLACE VIEW faro.v_action_workflow_detail AS
SELECT
  a.company_id,
  a.action_id,
  a.action_code,
  ad.name AS catalog_name,
  a.title,
  a.description,
  a.action_type,
  a.status,
  a.priority,
  a.due_date,

  CASE
    WHEN a.status NOT IN ('closed', 'cancelled', 'rejected')
     AND a.due_date < CURRENT_DATE THEN true
    ELSE false
  END AS is_overdue,

  a.responsible_user_id,
  ru.full_name AS responsible_name,
  ru.email AS responsible_email,

  a.approver_user_id,
  au.full_name AS approver_name,
  au.email AS approver_email,

  a.evidence_required,
  a.closure_criteria,
  a.expected_impact,
  a.expected_impact_amount,

  ad.executive_purpose,
  ad.success_metric,
  ad.expected_business_impact,
  ad.expected_score_recovery_min,
  ad.expected_score_recovery_max,
  ad.score_dimension AS action_score_dimension,

  t.tension_id,
  t.tension_code,
  t.title AS tension_title,
  t.description AS tension_description,
  t.severity AS tension_severity,
  t.priority_score AS tension_priority_score,
  t.score_impact AS tension_score_impact,

  td.business_question,
  td.executive_diagnosis,
  td.trigger_logic,
  td.area_code,
  td.module_code,

  a.payload,
  a.created_at,
  a.updated_at

FROM faro.actions a

LEFT JOIN faro.action_definitions ad
  ON ad.action_code = a.action_code
 AND ad.status = 'active'

LEFT JOIN faro.users ru
  ON ru.user_id = a.responsible_user_id

LEFT JOIN faro.users au
  ON au.user_id = a.approver_user_id

LEFT JOIN faro.tensions t
  ON t.tension_id = a.tension_id
 AND t.company_id = a.company_id

LEFT JOIN faro.tension_definitions td
  ON td.tension_code = t.tension_code
 AND td.status = 'active';

-- RLS: la vista hereda RLS de faro.actions vía company_id
-- Index recomendado: faro.actions(company_id, action_id) ya existente

CREATE OR REPLACE VIEW faro.v_action_evidence_detail AS
SELECT
  a.company_id,
  a.action_id,
  required.evidence_code,

  ed.name,
  ed.description,
  ed.evidence_type,
  ed.trust_level,
  ed.requires_review,
  ed.can_close_action,
  ed.allowed_submission_modes,
  ed.allowed_file_types,
  ed.required_metadata_keys,
  ed.validation_rules,

  COUNT(e.evidence_id) AS submitted_count,
  COUNT(e.evidence_id) FILTER (
    WHERE e.status = 'approved'
  ) AS approved_count,
  COUNT(e.evidence_id) FILTER (
    WHERE e.status = 'rejected'
  ) AS rejected_count,

  CASE
    WHEN COUNT(e.evidence_id) FILTER (WHERE e.status = 'approved') > 0 THEN 'approved'
    WHEN COUNT(e.evidence_id) FILTER (WHERE e.status = 'submitted') > 0 THEN 'submitted'
    WHEN COUNT(e.evidence_id) FILTER (WHERE e.status = 'rejected') > 0 THEN 'rejected'
    ELSE 'missing'
  END AS evidence_status

FROM faro.actions a

LEFT JOIN faro.action_definitions ad
  ON ad.action_code = a.action_code
 AND ad.status = 'active'

CROSS JOIN LATERAL unnest(
  COALESCE(ad.evidence_required_codes, ARRAY[]::text[])
) AS required(evidence_code)

LEFT JOIN faro.evidence_definitions ed
  ON ed.evidence_code = required.evidence_code
 AND ed.status = 'active'

LEFT JOIN faro.evidence e
  ON e.company_id = a.company_id
 AND e.action_id = a.action_id
 AND e.evidence_code = required.evidence_code

GROUP BY
  a.company_id,
  a.action_id,
  required.evidence_code,
  ed.name,
  ed.description,
  ed.evidence_type,
  ed.trust_level,
  ed.requires_review,
  ed.can_close_action,
  ed.allowed_submission_modes,
  ed.allowed_file_types,
  ed.required_metadata_keys,
  ed.validation_rules;

CREATE TABLE IF NOT EXISTS faro.execution_events (
  execution_event_id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

  company_id uuid NOT NULL,

  -- contexto: al menos uno de action_id, evidence_id, decision_id debe estar
  action_id   uuid NULL,
  evidence_id uuid NULL,
  decision_id uuid NULL,
  tension_id  uuid NULL,

  event_category text NOT NULL CHECK (
    event_category IN (
      'action', 'evidence', 'extension', 'escalation',
      'comment', 'decision', 'audit'
    )
  ),

  event_type text NOT NULL CHECK (
    event_type IN (
      -- action workflow (10)
      'action_created', 'action_started', 'status_changed',
      'action_blocked', 'action_unblocked', 'action_escalated',
      'action_closed', 'action_closed_with_override',
      'action_cancelled', 'action_reassigned',
      -- evidence (8)
      'evidence_uploaded', 'submitted_to_review',
      'evidence_approved', 'evidence_rejected',
      'evidence_needs_more_info', 'evidence_replaced',
      'evidence_archived', 'evidence_metadata_updated',
      -- extension (5)
      'extension_requested', 'extension_approved',
      'extension_rejected', 'due_date_changed',
      'extension_expired',
      -- escalation (4)
      'escalation_triggered', 'escalation_assigned',
      'escalation_acknowledged', 'escalation_resolved',
      -- comment / comms (5)
      'comment_added', 'internal_note_added',
      'notification_sent', 'reminder_sent', 'mention_added',
      -- decision / impact (4)
      'decision_logged', 'score_recovery_applied',
      'score_recovery_reversed', 'kpi_recalculated',
      -- audit (4)
      'permission_check_failed', 'invalid_transition_attempted',
      'integration_synced', 'data_quality_flag_raised'
    )
  ),

  actor_user_id uuid NULL,
  actor_role    text NULL,
  actor_kind    text NOT NULL DEFAULT 'human'
    CHECK (actor_kind IN ('human', 'system', 'integration', 'webhook')),

  from_status text NULL,
  to_status   text NULL,

  title       text NOT NULL,
  description text NULL,

  payload jsonb NOT NULL DEFAULT '{}'::jsonb,

  occurred_at timestamptz NOT NULL DEFAULT now(),
  created_at  timestamptz NOT NULL DEFAULT now(),

  CHECK (
    action_id IS NOT NULL
    OR evidence_id IS NOT NULL
    OR decision_id IS NOT NULL
  )
);

CREATE INDEX IF NOT EXISTS idx_exec_events_company_action
  ON faro.execution_events(company_id, action_id, occurred_at DESC)
  WHERE action_id IS NOT NULL;

CREATE INDEX IF NOT EXISTS idx_exec_events_company_evidence
  ON faro.execution_events(company_id, evidence_id, occurred_at DESC)
  WHERE evidence_id IS NOT NULL;

CREATE INDEX IF NOT EXISTS idx_exec_events_category_type
  ON faro.execution_events(event_category, event_type);

CREATE INDEX IF NOT EXISTS idx_exec_events_actor
  ON faro.execution_events(actor_user_id, occurred_at DESC);

-- RLS por company_id
ALTER TABLE faro.execution_events ENABLE ROW LEVEL SECURITY;

CREATE POLICY execution_events_rls
  ON faro.execution_events
  USING (company_id::text = current_setting('app.company_id', true));

-- Vista compatibilidad: action_events queda como filtro
CREATE OR REPLACE VIEW faro.action_events AS
SELECT *
FROM faro.execution_events
WHERE event_category = 'action'
   OR action_id IS NOT NULL;

CREATE OR REPLACE FUNCTION faro.can_close_action(p_action_id uuid)
RETURNS TABLE (
  can_close boolean,
  blocking_reasons text[]
) AS $$
DECLARE
  v_missing_count   integer;
  v_action_status   text;
  v_action_priority text;
  v_closure_criteria text;
  v_evidence_count  integer;
  v_reasons         text[] := ARRAY[]::text[];
BEGIN
  -- 1. Leer estado actual de la acción
  SELECT status, priority, closure_criteria
  INTO v_action_status, v_action_priority, v_closure_criteria
  FROM faro.actions
  WHERE action_id = p_action_id;

  IF v_action_status IS NULL THEN
    RETURN QUERY SELECT false, ARRAY['Acción inexistente']::text[];
    RETURN;
  END IF;

  -- 2. Estados terminales no se reabren
  IF v_action_status IN ('closed', 'cancelled', 'rejected') THEN
    RETURN QUERY SELECT false, ARRAY['La acción ya no está abierta']::text[];
    RETURN;
  END IF;

  -- 3. Bloqueada no se cierra
  IF v_action_status = 'blocked' THEN
    v_reasons := array_append(v_reasons, 'La acción está bloqueada');
  END IF;

  -- 4. Necesita criterio de cierre
  IF v_closure_criteria IS NULL OR trim(v_closure_criteria) = '' THEN
    v_reasons := array_append(v_reasons, 'La acción no tiene criterio de cierre');
  END IF;

  -- 5. Cuenta de evidencia requerida
  SELECT COUNT(*)
  INTO v_evidence_count
  FROM faro.v_action_evidence_detail
  WHERE action_id = p_action_id;

  IF v_evidence_count = 0 THEN
    v_reasons := array_append(v_reasons, 'La acción no tiene evidencia requerida configurada');
  END IF;

  -- 6. Evidencias requeridas con estado distinto de approved
  SELECT COUNT(*)
  INTO v_missing_count
  FROM faro.v_action_evidence_detail
  WHERE action_id = p_action_id
    AND evidence_status <> 'approved';

  IF v_missing_count > 0 THEN
    FOR r IN
      SELECT evidence_code, name
      FROM faro.v_action_evidence_detail
      WHERE action_id = p_action_id
        AND evidence_status <> 'approved'
      ORDER BY evidence_code
    LOOP
      v_reasons := array_append(
        v_reasons,
        format('Falta %s · %s', r.evidence_code, r.name)
      );
    END LOOP;
  END IF;

  -- 7. Si priority='critical', requiere aprobador con rol senior
  IF v_action_priority = 'critical' THEN
    IF NOT EXISTS (
      SELECT 1
      FROM faro.actions a
      JOIN faro.users u ON u.user_id = a.approver_user_id
      WHERE a.action_id = p_action_id
        AND u.role IN ('general_manager', 'director')
    ) THEN
      v_reasons := array_append(
        v_reasons,
        'Acción crítica requiere aprobador general_manager o director'
      );
    END IF;
  END IF;

  RETURN QUERY SELECT cardinality(v_reasons) = 0, v_reasons;
END;
$$ LANGUAGE plpgsql STABLE;

-- Test rápido en la demo:
-- SELECT * FROM faro.can_close_action('23000000-0000-0000-0000-000000000001');
-- Esperado para Empresa Demo Cuyo S.A.:
--   can_close = false
--   blocking_reasons = {'Falta EVD-007 · Cambio de política',
--                       'Falta EVD-012 · Validación de dirección'}

export type ActionWorkflowStatus =
  | "new"
  | "in_progress"
  | "waiting_evidence"
  | "in_review"
  | "approved"
  | "closed"
  | "blocked"
  | "expired"
  | "rejected"
  | "cancelled";

export type ActionWorkflowPriority =
  | "low"
  | "medium"
  | "high"
  | "critical";

export type EvidenceStatus =
  | "missing"
  | "submitted"
  | "approved"
  | "rejected"
  | "needs_more_info";

export type EvidenceRequirementDetail = {
  evidence_code: string;
  name: string;
  description: string | null;
  evidence_type: string;
  trust_level: "low" | "medium" | "high" | "critical";
  requires_review: boolean;
  can_close_action: boolean;
  status: EvidenceStatus;
  submitted_count: number;
  approved_count: number;
};

export type SubmittedEvidence = {
  evidence_id: string;
  evidence_code: string;
  title: string;
  description: string | null;
  status: "submitted" | "approved" | "rejected" | "needs_more_info";
  submitted_by: string | null;
  submitted_at: string;
  reviewed_by: string | null;
  reviewed_at: string | null;
  review_comment: string | null;
};

export type ActionTimelineEvent = {
  event_id: string;
  event_type: string;
  title: string;
  description: string | null;
  actor: { full_name: string | null };
  created_at: string;
};

export type ActionWorkflowDetailResponse = {
  action: {
    action_id: string;
    action_code: string;
    title: string;
    description: string | null;
    status: ActionWorkflowStatus;
    priority: ActionWorkflowPriority;
    action_type: string;
    due_date: string | null;
    is_overdue: boolean;
    closure_criteria: string | null;
    expected_impact: string | null;
    expected_score_recovery_min: number | null;
    expected_score_recovery_max: number | null;
    created_at: string;
    updated_at: string;
  };
  responsible: {
    user_id: string | null;
    full_name: string | null;
    email: string | null;
    role?: string | null;
  };
  approver: {
    user_id: string | null;
    full_name: string | null;
    email: string | null;
    role?: string | null;
  };
  tension: {
    tension_id: string | null;
    tension_code: string | null;
    title: string | null;
    severity: string | null;
    priority_score: number | null;
    score_impact: number | null;
    business_question: string | null;
    executive_diagnosis: string | null;
  };
  evidence_requirements: EvidenceRequirementDetail[];
  submitted_evidence: SubmittedEvidence[];
  workflow: {
    can_start: boolean;
    can_upload_evidence: boolean;
    can_submit_review: boolean;
    can_approve: boolean;
    can_reject: boolean;
    can_close: boolean;
    can_block: boolean;
    can_escalate: boolean;
    can_request_extension: boolean;
    blocking_reasons: string[];
  };
  timeline: ActionTimelineEvent[];
};

import { ActionWorkflowPage } from "@/components/action-workflow/ActionWorkflowPage";

export default function Page({ params }: { params: { id: string } }) {
  return <ActionWorkflowPage actionId={params.id} />;
}

"use client";

import { useEffect, useState } from "react";
import { getActionWorkflowDetail } from "@/lib/faro/action-workflow.api";
import type { ActionWorkflowDetailResponse } from "@/lib/faro/action-workflow.types";
import { ActionWorkflowHeader } from "./ActionWorkflowHeader";
import { ActionStatusStepper } from "./ActionStatusStepper";
import { ActionPurposeBlock } from "./ActionPurposeBlock";
import { ActionClosureCriteria } from "./ActionClosureCriteria";
import { LinkedTensionSummary } from "./LinkedTensionSummary";
import { EvidenceRequirementChecklist } from "./EvidenceRequirementChecklist";
import { EvidenceSubmittedList } from "./EvidenceSubmittedList";
import { ActionTimeline } from "./ActionTimeline";
import { ActionScoreImpact } from "./ActionScoreImpact";
import { ActionWorkflowFooter } from "./ActionWorkflowFooter";

export function ActionWorkflowPage({ actionId }: { actionId: string }) {
  const [data, setData] = useState<ActionWorkflowDetailResponse | null>(null);
  const [loading, setLoading] = useState(true);

  async function reload() {
    const result = await getActionWorkflowDetail(actionId);
    setData(result);
  }

  useEffect(() => {
    let cancelled = false;
    (async () => {
      setLoading(true);
      try {
        const result = await getActionWorkflowDetail(actionId);
        if (!cancelled) setData(result);
      } finally {
        if (!cancelled) setLoading(false);
      }
    })();
    return () => { cancelled = true; };
  }, [actionId]);

  if (loading && !data) return <LoadingState />;
  if (!data) return <ErrorState />;

  return (
    <main className="min-h-screen bg-[#F7FAFF] px-4 py-5 text-[#071A44] md:px-6 md:py-6">
      <div className="mx-auto flex max-w-7xl flex-col gap-5">
        <ActionWorkflowHeader data={data} />
        <ActionStatusStepper status={data.action.status} />

        <section className="grid gap-5 xl:grid-cols-[1.2fr_.8fr]">
          <div className="space-y-5">
            <ActionPurposeBlock data={data} />
            <ActionClosureCriteria data={data} />
            <EvidenceSubmittedList evidence={data.submitted_evidence} />
            <ActionTimeline events={data.timeline} />
          </div>

          <aside className="space-y-5">
            <LinkedTensionSummary tension={data.tension} />
            <EvidenceRequirementChecklist requirements={data.evidence_requirements} />
            <ActionScoreImpact action={data.action} />
          </aside>
        </section>

        <ActionWorkflowFooter data={data} onChanged={reload} />
      </div>
    </main>
  );
}

import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/server/db";
import { getSessionContext } from "@/lib/server/session";

export async function GET(
  _request: NextRequest,
  { params }: { params: { id: string } }
) {
  const session = await getSessionContext();

  if (!session?.companyId || !session?.userId) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  const client = await db.connect();

  try {
    await client.query("BEGIN");

    // Setear RLS por sesión
    await client.query(`SELECT set_config('app.company_id', $1, true)`, [session.companyId]);
    await client.query(`SELECT set_config('app.user_id', $1, true)`,    [session.userId]);
    await client.query(`SELECT set_config('app.role_codes', $1, true)`, [session.roleCodes.join(",")]);

    // Detalle desde la vista
    const actionResult = await client.query(
      `SELECT * FROM faro.v_action_workflow_detail
        WHERE company_id = $1 AND action_id = $2 LIMIT 1`,
      [session.companyId, params.id]
    );

    if (actionResult.rows.length === 0) {
      await client.query("ROLLBACK");
      return NextResponse.json({ error: "Action not found" }, { status: 404 });
    }
    const action = actionResult.rows[0];

    const evidenceRequirements = await client.query(
      `SELECT * FROM faro.v_action_evidence_detail
        WHERE company_id = $1 AND action_id = $2 ORDER BY evidence_code`,
      [session.companyId, params.id]
    );

    const submittedEvidence = await client.query(
      `SELECT e.*, su.full_name AS submitted_by_name,
              ru.full_name AS reviewed_by_name
         FROM faro.evidence e
         LEFT JOIN faro.users su ON su.user_id = e.submitted_by
         LEFT JOIN faro.users ru ON ru.user_id = e.reviewed_by
        WHERE e.company_id = $1 AND e.action_id = $2
        ORDER BY e.submitted_at DESC`,
      [session.companyId, params.id]
    );

    const timeline = await client.query(
      `SELECT ee.execution_event_id AS event_id, ee.event_type, ee.title,
              ee.description, u.full_name AS actor_name, ee.occurred_at AS created_at
         FROM faro.execution_events ee
         LEFT JOIN faro.users u ON u.user_id = ee.actor_user_id
        WHERE ee.company_id = $1 AND ee.action_id = $2
        ORDER BY ee.occurred_at ASC`,
      [session.companyId, params.id]
    );

    const closeCheck = await client.query(
      `SELECT * FROM faro.can_close_action($1)`,
      [params.id]
    );

    await client.query("COMMIT");

    const canClose = closeCheck.rows[0]?.can_close ?? false;
    const blockingReasons = closeCheck.rows[0]?.blocking_reasons ?? [];

    return NextResponse.json({
      action: mapAction(action),
      responsible: mapUser(action, "responsible"),
      approver:    mapUser(action, "approver"),
      tension:     mapTension(action),
      evidence_requirements: evidenceRequirements.rows.map(mapEvidenceRequirement),
      submitted_evidence:    submittedEvidence.rows.map(mapSubmittedEvidence),
      workflow: buildWorkflow(action, canClose, blockingReasons, session),
      timeline: timeline.rows.map(mapTimelineEvent)
    });
  } catch (error) {
    await client.query("ROLLBACK");
    return NextResponse.json({ error: "Could not load action detail" }, { status: 500 });
  } finally {
    client.release();
  }
}

function buildWorkflow(action: any, canClose: boolean, blockingReasons: string[], session: any) {
  const isResponsible = action.responsible_user_id === session.userId;
  const isApprover    = action.approver_user_id    === session.userId;
  const isManager = session.roleCodes.includes("general_manager")
                || session.roleCodes.includes("director");

  return {
    can_start: isResponsible && action.status === "new",
    can_upload_evidence: isResponsible &&
      ["new", "in_progress", "waiting_evidence", "expired"].includes(action.status),
    can_submit_review: isResponsible &&
      ["waiting_evidence", "in_progress", "expired"].includes(action.status),
    can_approve: (isApprover || isManager) && action.status === "in_review",
    can_reject:  (isApprover || isManager) && action.status === "in_review",
    can_close:   canClose && (isApprover || isManager),
    can_block:   isResponsible && !["closed", "cancelled", "rejected"].includes(action.status),
    can_escalate: isResponsible || isManager,
    can_request_extension: isResponsible &&
      !["closed", "cancelled", "rejected"].includes(action.status),
    blocking_reasons: blockingReasons
  };
}

import { describe, expect, it } from "vitest";
import { withTestDbContext } from "../src/helpers/dbTestContext";

describe("FARO-UI-003 · Regla dura de cierre", () => {
  it("no cierra acción sin evidencia aprobada", async () => {
    await withTestDbContext(
      {
        companyId: "10000000-0000-0000-0000-000000000001", // Empresa Demo Cuyo S.A.
        userId:    "12000000-0000-0000-0000-000000000001", // Tomás Pombo (general_manager)
        roleCodes: ["general_manager"]
      },
      async (client) => {
        const result = await client.query(
          `SELECT * FROM faro.can_close_action($1)`,
          ["23000000-0000-0000-0000-000000000001"] // ACT-COM-001
        );

        expect(result.rows[0].can_close).toBe(false);
        expect(result.rows[0].blocking_reasons.length).toBeGreaterThan(0);
        expect(result.rows[0].blocking_reasons).toContain("Falta EVD-007 · Cambio de política");
        expect(result.rows[0].blocking_reasons).toContain("Falta EVD-012 · Validación de dirección");
      }
    );
  });

  it("genera evento action_closed al cerrar con evidencia", async () => {
    // 1. Cargar y aprobar EVD-007 y EVD-012 sobre ACT-COM-001
    // 2. POST /api/v1/actions/:id/close
    // 3. Verificar response 200
    // 4. Verificar que existe evento execution_events con event_type='action_closed'
  });
});